From 33b28b69609267a719557474ae67f159bda95922 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 12:51:22 -0700 Subject: [PATCH 01/21] move dummy devices into elec model --- edg/abstract_parts/Categories.py | 7 --- edg/abstract_parts/DummyDevices.py | 25 ---------- edg/abstract_parts/__init__.py | 1 - edg/electronics_model/DummyDevice.py | 8 +++ edg/electronics_model/GroundDummyDevice.py | 9 ++++ edg/electronics_model/PassivePort.py | 34 +++++++++++-- edg/electronics_model/VoltageDummyDevice.py | 22 +++++++++ edg/electronics_model/VoltagePorts.py | 54 +++++++++++++++++++-- edg/electronics_model/__init__.py | 5 ++ 9 files changed, 123 insertions(+), 42 deletions(-) create mode 100644 edg/electronics_model/DummyDevice.py create mode 100644 edg/electronics_model/GroundDummyDevice.py create mode 100644 edg/electronics_model/VoltageDummyDevice.py diff --git a/edg/abstract_parts/Categories.py b/edg/abstract_parts/Categories.py index 7174f76d4..169c26b9a 100644 --- a/edg/abstract_parts/Categories.py +++ b/edg/abstract_parts/Categories.py @@ -384,13 +384,6 @@ class PassiveComponent(DiscreteComponent): pass -@abstract_block -class DummyDevice(InternalBlock): - """Non-physical "device" used to affect parameters.""" - - pass - - @abstract_block class IdealModel(InternalBlock): """Ideal model device that can be used as a placeholder to get a design compiling diff --git a/edg/abstract_parts/DummyDevices.py b/edg/abstract_parts/DummyDevices.py index 7bd0ab83a..0ef9b3865 100644 --- a/edg/abstract_parts/DummyDevices.py +++ b/edg/abstract_parts/DummyDevices.py @@ -10,31 +10,6 @@ def __init__(self) -> None: self.io = self.Port(Passive(), [InOut]) -class DummyGround(DummyDevice): - def __init__(self) -> None: - super().__init__() - self.gnd = self.Port(Ground(), [Common, InOut]) - - -class DummyVoltageSource(DummyDevice): - def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL) -> None: - super().__init__() - - self.pwr = self.Port(VoltageSource(voltage_out=voltage_out, current_limits=current_limits), [Power, InOut]) - - self.current_drawn = self.Parameter(RangeExpr(self.pwr.link().current_drawn)) - self.voltage_limits = self.Parameter(RangeExpr(self.pwr.link().voltage_limits)) - - -class DummyVoltageSink(DummyDevice): - def __init__(self, voltage_limit: RangeLike = RangeExpr.ALL, current_draw: RangeLike = RangeExpr.ZERO) -> None: - super().__init__() - - self.pwr = self.Port(VoltageSink(voltage_limits=voltage_limit, current_draw=current_draw), [Power, InOut]) - self.voltage = self.Parameter(RangeExpr(self.pwr.link().voltage)) - self.current_limits = self.Parameter(RangeExpr(self.pwr.link().current_limits)) - - class DummyDigitalSource(DummyDevice): def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL) -> None: super().__init__() diff --git a/edg/abstract_parts/__init__.py b/edg/abstract_parts/__init__.py index e20252e13..49cba6a7b 100644 --- a/edg/abstract_parts/__init__.py +++ b/edg/abstract_parts/__init__.py @@ -11,7 +11,6 @@ PartsTableSelectorFootprint, ) -from .Categories import DummyDevice from .Categories import DiscreteComponent, DiscreteSemiconductor, PassiveComponent from .Categories import DiscreteApplication from .Categories import Analog, OpampApplication diff --git a/edg/electronics_model/DummyDevice.py b/edg/electronics_model/DummyDevice.py new file mode 100644 index 000000000..aa0410940 --- /dev/null +++ b/edg/electronics_model/DummyDevice.py @@ -0,0 +1,8 @@ +from ..electronics_model import abstract_block, InternalBlock + + +@abstract_block +class DummyDevice(InternalBlock): + """Non-physical "device" used to affect parameters or for unit testing.""" + + pass diff --git a/edg/electronics_model/GroundDummyDevice.py b/edg/electronics_model/GroundDummyDevice.py new file mode 100644 index 000000000..183ac13e4 --- /dev/null +++ b/edg/electronics_model/GroundDummyDevice.py @@ -0,0 +1,9 @@ +from .DummyDevice import DummyDevice +from .GroundPort import Ground, Common +from ..core import InOut + + +class DummyGround(DummyDevice): + def __init__(self) -> None: + super().__init__() + self.gnd = self.Port(Ground(), [Common, InOut]) diff --git a/edg/electronics_model/PassivePort.py b/edg/electronics_model/PassivePort.py index 91850e338..4fbe5d528 100644 --- a/edg/electronics_model/PassivePort.py +++ b/edg/electronics_model/PassivePort.py @@ -27,18 +27,44 @@ def __init__(self, voltage_limits: RangeLike = RangeExpr.ALL): class PassiveAdapterVoltageSource(CircuitPortAdapter[VoltageSource]): # TODO we can't use **kwargs b/c init_in_parent needs the initializer list - def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL): + def __init__( + self, + voltage_out: RangeLike = RangeExpr.ZERO, + current_limits: RangeLike = RangeExpr.ALL, + reverse_voltage_limits: RangeLike = RangeExpr.EMPTY, + reverse_current_draw: RangeLike = RangeExpr.EMPTY, + ): super().__init__() self.src = self.Port(Passive()) - self.dst = self.Port(VoltageSource(voltage_out=voltage_out, current_limits=current_limits)) + self.dst = self.Port( + VoltageSource( + voltage_out=voltage_out, + current_limits=current_limits, + reverse_voltage_limits=reverse_voltage_limits, + reverse_current_draw=reverse_current_draw, + ) + ) class PassiveAdapterVoltageSink(CircuitPortAdapter[VoltageSink]): # TODO we can't use **kwargs b/c the init hook needs an initializer list - def __init__(self, voltage_limits: RangeLike = RangeExpr.ALL, current_draw: RangeLike = RangeExpr.ZERO): + def __init__( + self, + voltage_limits: RangeLike = RangeExpr.ALL, + current_draw: RangeLike = RangeExpr.ZERO, + reverse_voltage_out: RangeLike = RangeExpr.EMPTY, + reverse_current_limits: RangeLike = RangeExpr.EMPTY, + ): super().__init__() self.src = self.Port(Passive()) - self.dst = self.Port(VoltageSink(voltage_limits=voltage_limits, current_draw=current_draw)) + self.dst = self.Port( + VoltageSink( + voltage_limits=voltage_limits, + current_draw=current_draw, + reverse_voltage_out=reverse_voltage_out, + reverse_current_limits=reverse_current_limits, + ) + ) class PassiveAdapterDigitalSource(CircuitPortAdapter[DigitalSource]): diff --git a/edg/electronics_model/VoltageDummyDevice.py b/edg/electronics_model/VoltageDummyDevice.py new file mode 100644 index 000000000..e1c62925a --- /dev/null +++ b/edg/electronics_model/VoltageDummyDevice.py @@ -0,0 +1,22 @@ +from .DummyDevice import DummyDevice +from .VoltagePorts import VoltageSource, VoltageSink, Power +from ..core import RangeExpr, RangeLike, InOut + + +class DummyVoltageSource(DummyDevice): + def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL) -> None: + super().__init__() + + self.pwr = self.Port(VoltageSource(voltage_out=voltage_out, current_limits=current_limits), [Power, InOut]) + + self.current_drawn = self.Parameter(RangeExpr(self.pwr.link().current_drawn)) + self.voltage_limits = self.Parameter(RangeExpr(self.pwr.link().voltage_limits)) + + +class DummyVoltageSink(DummyDevice): + def __init__(self, voltage_limit: RangeLike = RangeExpr.ALL, current_draw: RangeLike = RangeExpr.ZERO) -> None: + super().__init__() + + self.pwr = self.Port(VoltageSink(voltage_limits=voltage_limit, current_draw=current_draw), [Power, InOut]) + self.voltage = self.Parameter(RangeExpr(self.pwr.link().voltage)) + self.current_limits = self.Parameter(RangeExpr(self.pwr.link().current_limits)) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index c1a479eef..a9b519bb1 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -41,6 +41,12 @@ def __init__(self) -> None: self.current_drawn = self.Parameter(RangeExpr()) self.current_limits = self.Parameter(RangeExpr()) + self.has_reverse_voltage = self.Parameter(BoolExpr()) + self.reverse_voltage = self.Parameter(RangeExpr()) + self.reverse_voltage_limits = self.Parameter(RangeExpr()) + self.reverse_current_drawn = self.Parameter(RangeExpr()) + self.reverse_current_limits = self.Parameter(RangeExpr()) + @override def contents(self) -> None: super().contents() @@ -58,11 +64,31 @@ def contents(self) -> None: self.assign(self.voltage, self.source.voltage_out) self.assign(self.voltage_limits, self.sinks.intersection(lambda x: x.voltage_limits)) - self.require(self.voltage_limits.contains(self.voltage), "overvoltage") + self.require(self.voltage_limits.contains(self.voltage), "voltage out of limits") self.assign(self.current_limits, self.source.current_limits) - self.assign(self.current_drawn, self.sinks.sum(lambda x: x.current_draw)) - self.require(self.current_limits.contains(self.current_drawn), "overcurrent") + self.require(self.current_limits.contains(self.current_drawn), "current draw out of limits") + + # TODO limit to one reverse voltage source + self.assign(self.has_reverse_voltage, self.reverse_voltage != RangeExpr.EMPTY) + self.assign(self.reverse_voltage, self.sinks.hull(lambda x: x.reverse_voltage_out)) + self.assign(self.reverse_voltage_limits, self.source.reverse_voltage_limits) + # use implications to gate the reverse voltage requirements, since not all sources will support reverse voltage + self.require( + self.has_reverse_voltage.implies(self.reverse_voltage_limits != RangeExpr.EMPTY), + "reverse voltage source must have reverse voltage sink", + ) + self.require( + self.has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.reverse_voltage)), + "reverse voltage limits out of range", + ) + + self.assign(self.reverse_current_drawn, self.source.reverse_current_draw) + self.assign(self.reverse_current_limits, self.sinks.hull(lambda x: x.reverse_current_limits)) + self.require( + self.has_reverse_voltage.implies(self.reverse_current_limits.contains(self.reverse_current_drawn)), + "reverse current out of limits", + ) class VoltageSinkBridge(CircuitPortBridge): @@ -139,11 +165,20 @@ def from_gnd( ) -> "VoltageSink": return VoltageSink(voltage_limits=gnd.link().voltage + voltage_limits, current_draw=current_draw) - def __init__(self, voltage_limits: RangeLike = RangeExpr.ALL, current_draw: RangeLike = RangeExpr.ZERO) -> None: + def __init__( + self, + voltage_limits: RangeLike = RangeExpr.ALL, + current_draw: RangeLike = RangeExpr.ZERO, + reverse_voltage_out: RangeLike = RangeExpr.EMPTY, + reverse_current_limits: RangeLike = RangeExpr.EMPTY, + ) -> None: super().__init__() self.voltage_limits: RangeExpr = self.Parameter(RangeExpr(voltage_limits)) self.current_draw: RangeExpr = self.Parameter(RangeExpr(current_draw)) + self.reverse_voltage_out: RangeExpr = self.Parameter(RangeExpr(reverse_voltage_out)) + self.reverse_current_limits: RangeExpr = self.Parameter(RangeExpr(reverse_current_limits)) + class VoltageSinkAdapterGroundReference(CircuitPortAdapter["GroundReference"]): def __init__(self, current_draw: RangeLike): @@ -194,10 +229,19 @@ def __init__(self) -> None: class VoltageSource(VoltageBase): bridge_type = VoltageSourceBridge - def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL) -> None: + def __init__( + self, + voltage_out: RangeLike = RangeExpr.ZERO, + current_limits: RangeLike = RangeExpr.ALL, + reverse_voltage_limits: RangeLike = RangeExpr.EMPTY, + reverse_current_draw: RangeLike = RangeExpr.EMPTY, + ) -> None: super().__init__() self.voltage_out: RangeExpr = self.Parameter(RangeExpr(voltage_out)) self.current_limits: RangeExpr = self.Parameter(RangeExpr(current_limits)) + self.reverse_voltage_limits: RangeExpr = self.Parameter(RangeExpr(reverse_voltage_limits)) + self.reverse_current_draw: RangeExpr = self.Parameter(RangeExpr(reverse_current_draw)) + Power = PortTag(VoltageSink) # General positive voltage port, should only be mutually exclusive with the below diff --git a/edg/electronics_model/__init__.py b/edg/electronics_model/__init__.py index acdb0fdaa..0a9da5ec5 100644 --- a/edg/electronics_model/__init__.py +++ b/edg/electronics_model/__init__.py @@ -40,6 +40,11 @@ from .KiCadImportableBlock import KiCadImportableBlock, KiCadInstantiableBlock from .KiCadSchematicBlock import KiCadSchematicBlock +# model-breaking constructs, including for unit testing +from .DummyDevice import DummyDevice +from .GroundDummyDevice import DummyGround +from .VoltageDummyDevice import DummyVoltageSource, DummyVoltageSink + # for power users to build custom blackbox handlers from .KiCadSchematicParser import KiCadSymbol, KiCadLibSymbol from .KiCadSchematicBlock import KiCadBlackbox, KiCadBlackboxBase From 0ceb37e60bcd92cf3b3df42600835f892b54fbe9 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 14:03:12 -0700 Subject: [PATCH 02/21] wip voltage unit test --- edg/electronics_model/test_voltage_link.py | 82 ++++++++++++++++++++-- 1 file changed, 77 insertions(+), 5 deletions(-) diff --git a/edg/electronics_model/test_voltage_link.py b/edg/electronics_model/test_voltage_link.py index 1e8ca8c60..18787a866 100644 --- a/edg/electronics_model/test_voltage_link.py +++ b/edg/electronics_model/test_voltage_link.py @@ -3,12 +3,84 @@ from typing_extensions import override from .VoltagePorts import VoltageLink +from . import * + + +class VoltageTestTop(DesignTop): + """Test design with single voltage source and sink with valid ranges""" + + def __init__(self) -> None: + super().__init__() + self.src = self.Block(DummyVoltageSource(voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp)) + self.sink = self.Block(DummyVoltageSink(voltage_limit=5 * Volt(tol=0.1), current_draw=1 * Amp(tol=0))) + self.connect(self.src.pwr, self.sink.pwr) + + +class NoSourceVoltageTest(DesignTop): + """Test design with missing source""" + + def __init__(self) -> None: + super().__init__() + self.sink = self.Block(DummyVoltageSink(voltage_limit=5 * Volt(tol=0.1), current_draw=1 * Amp(tol=0))) + + +class OvervoltageTestTop(DesignTop): + """Test design with single source and single restrictive sink""" + + def __init__(self) -> None: + super().__init__() + self.src = self.Block(DummyVoltageSource(voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp)) + self.sink = self.Block(DummyVoltageSink(voltage_limit=3.3 * Volt(tol=0.1), current_draw=1 * Amp(tol=0))) + self.connect(self.src.pwr, self.sink.pwr) + + +class OvercurrentTestTop(DesignTop): + """Test design with single source and single restrictive sink""" + + def __init__(self) -> None: + super().__init__() + self.src = self.Block(DummyVoltageSource(voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp)) + self.sink1 = self.Block(DummyVoltageSink(voltage_limit=5 * Volt(tol=0.1), current_draw=1 * Amp(tol=0))) + self.sink2 = self.Block(DummyVoltageSink(voltage_limit=5 * Volt(tol=0.1), current_draw=1 * Amp(tol=0))) + self.connect(self.src.pwr, self.sink1.pwr, self.sink2.pwr) + + +class ReverseVoltageTestTop(DesignTop): + """Test design with valid forward and reverse voltage flows""" + + def __init__(self) -> None: + super().__init__() + + +class NoReverseSinkVoltageTest(DesignTop): + """Test design with reverse voltage source but no sink""" + + def __init__(self) -> None: + super().__init__() + self.src = self.Block(DummyVoltageSource(voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp)) + self.sink = self.Block(DummyVoltageSink(voltage_limit=3.3 * Volt(tol=0.1), current_draw=1 * Amp(tol=0))) + self.connect(self.src.pwr, self.sink.pwr) class VoltageLinkTestCase(unittest.TestCase): - @override - def setUp(self) -> None: - self.pb = VoltageLink()._elaborated_def_to_proto() + def test_voltage(self) -> None: + ScalaCompiler.compile(VoltageTestTop) + + def test_no_source(self) -> None: + with self.assertRaises(CompilerCheckError): + ScalaCompiler.compile(NoSourceVoltageTest) + + def test_overvoltage(self) -> None: + with self.assertRaises(CompilerCheckError): + ScalaCompiler.compile(OvervoltageTestTop) + + def test_overcurrent(self) -> None: + with self.assertRaises(CompilerCheckError): + ScalaCompiler.compile(OvercurrentTestTop) + + def test_reverse_voltage(self) -> None: + ScalaCompiler.compile(ReverseVoltageTestTop) - def test_metadata(self) -> None: - self.assertIn("nets", self.pb.meta.members.node) + def test_no_reverse_sink(self) -> None: + with self.assertRaises(CompilerCheckError): + ScalaCompiler.compile(NoReverseSinkVoltageTest) From 14bce8061816faed50b15b2dd3420c9719bb30ad Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 14:20:15 -0700 Subject: [PATCH 03/21] wip reverse tests --- edg/electronics_model/VoltageDummyDevice.py | 38 ++++++++++-- edg/electronics_model/VoltagePorts.py | 5 ++ edg/electronics_model/test_voltage_link.py | 68 +++++++++++++++++++-- 3 files changed, 103 insertions(+), 8 deletions(-) diff --git a/edg/electronics_model/VoltageDummyDevice.py b/edg/electronics_model/VoltageDummyDevice.py index e1c62925a..3bc1c0de9 100644 --- a/edg/electronics_model/VoltageDummyDevice.py +++ b/edg/electronics_model/VoltageDummyDevice.py @@ -4,19 +4,49 @@ class DummyVoltageSource(DummyDevice): - def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL) -> None: + def __init__( + self, + voltage_out: RangeLike = RangeExpr.ZERO, + current_limits: RangeLike = RangeExpr.ALL, + reverse_voltage_limits: RangeLike = RangeExpr.EMPTY, + reverse_current_draw: RangeLike = RangeExpr.EMPTY, + ) -> None: super().__init__() - self.pwr = self.Port(VoltageSource(voltage_out=voltage_out, current_limits=current_limits), [Power, InOut]) + self.pwr = self.Port( + VoltageSource( + voltage_out=voltage_out, + current_limits=current_limits, + reverse_voltage_limits=reverse_voltage_limits, + reverse_current_draw=reverse_current_draw, + ), + [Power, InOut], + ) self.current_drawn = self.Parameter(RangeExpr(self.pwr.link().current_drawn)) self.voltage_limits = self.Parameter(RangeExpr(self.pwr.link().voltage_limits)) class DummyVoltageSink(DummyDevice): - def __init__(self, voltage_limit: RangeLike = RangeExpr.ALL, current_draw: RangeLike = RangeExpr.ZERO) -> None: + + def __init__( + self, + voltage_limit: RangeLike = RangeExpr.ALL, + current_draw: RangeLike = RangeExpr.ZERO, + reverse_voltage_out: RangeLike = RangeExpr.EMPTY, + reverse_current_limits: RangeLike = RangeExpr.EMPTY, + ) -> None: super().__init__() - self.pwr = self.Port(VoltageSink(voltage_limits=voltage_limit, current_draw=current_draw), [Power, InOut]) + self.pwr = self.Port( + VoltageSink( + voltage_limits=voltage_limit, + current_draw=current_draw, + reverse_voltage_out=reverse_voltage_out, + reverse_current_limits=reverse_current_limits, + ), + [Power, InOut], + ) + self.voltage = self.Parameter(RangeExpr(self.pwr.link().voltage)) self.current_limits = self.Parameter(RangeExpr(self.pwr.link().current_limits)) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index a9b519bb1..5f72e6b24 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -82,6 +82,11 @@ def contents(self) -> None: self.has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.reverse_voltage)), "reverse voltage limits out of range", ) + # this is a heuristic check, assuming that each source is non-zero-volts + self.require( + self.has_reverse_voltage.implies(self.reverse_voltage == self.sinks.sum(lambda x: x.reverse_voltage_out)), + "may not have multiple reverse voltage sources", + ) self.assign(self.reverse_current_drawn, self.source.reverse_current_draw) self.assign(self.reverse_current_limits, self.sinks.hull(lambda x: x.reverse_current_limits)) diff --git a/edg/electronics_model/test_voltage_link.py b/edg/electronics_model/test_voltage_link.py index 18787a866..f73b206db 100644 --- a/edg/electronics_model/test_voltage_link.py +++ b/edg/electronics_model/test_voltage_link.py @@ -50,15 +50,71 @@ class ReverseVoltageTestTop(DesignTop): def __init__(self) -> None: super().__init__() + self.src = self.Block( + DummyVoltageSource( + voltage_out=5 * Volt(tol=0), + current_limits=(0, 1) * Amp, + reverse_voltage_limits=5 * Volt(tol=0.1), + reverse_current_draw=0 * Amp, + ) + ) + self.sink = self.Block( + DummyVoltageSink( + voltage_limit=5 * Volt(tol=0.1), + current_draw=0 * Amp, + reverse_voltage_out=5 * Volt(tol=0), + reverse_current_limits=(0, 1) * Amp, + ) + ) + self.connect(self.src.pwr, self.sink.pwr) + + +class ReverseMultiSourceTestTop(DesignTop): + """Test design with (invalid) multiple reverse voltage sources""" + + def __init__(self) -> None: + super().__init__() + self.src = self.Block( + DummyVoltageSource( + voltage_out=5 * Volt(tol=0), + current_limits=(0, 1) * Amp, + reverse_voltage_limits=5 * Volt(tol=0.1), + reverse_current_draw=0 * Amp, + ) + ) + self.sink1 = self.Block( + DummyVoltageSink( + voltage_limit=5 * Volt(tol=0.1), + current_draw=0 * Amp, + reverse_voltage_out=5 * Volt(tol=0), + reverse_current_limits=(0, 1) * Amp, + ) + ) + self.sink2 = self.Block( + DummyVoltageSink( + voltage_limit=5 * Volt(tol=0.1), + current_draw=0 * Amp, + reverse_voltage_out=5 * Volt(tol=0), + reverse_current_limits=(0, 1) * Amp, + ) + ) + self.connect(self.src.pwr, self.sink1.pwr, self.sink2.pwr) -class NoReverseSinkVoltageTest(DesignTop): +class ReverseNoSinkTest(DesignTop): """Test design with reverse voltage source but no sink""" def __init__(self) -> None: super().__init__() self.src = self.Block(DummyVoltageSource(voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp)) - self.sink = self.Block(DummyVoltageSink(voltage_limit=3.3 * Volt(tol=0.1), current_draw=1 * Amp(tol=0))) + self.sink = self.Block( + DummyVoltageSink( + voltage_limit=5 * Volt(tol=0.1), + current_draw=0 * Amp, + reverse_voltage_out=5 * Volt(tol=0), + reverse_current_limits=(0, 1) * Amp, + ) + ) self.connect(self.src.pwr, self.sink.pwr) @@ -81,6 +137,10 @@ def test_overcurrent(self) -> None: def test_reverse_voltage(self) -> None: ScalaCompiler.compile(ReverseVoltageTestTop) - def test_no_reverse_sink(self) -> None: + def test_reverse_mult_source(self) -> None: + with self.assertRaises(CompilerCheckError): + ScalaCompiler.compile(ReverseMultiSourceTestTop) + + def test_reverse_no_sink(self) -> None: with self.assertRaises(CompilerCheckError): - ScalaCompiler.compile(NoReverseSinkVoltageTest) + ScalaCompiler.compile(ReverseNoSinkTest) From 170957d01f6d5abafd398b5308466802c1357ef3 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 17:00:03 -0700 Subject: [PATCH 04/21] wip --- edg/electronics_model/VoltageDummyDevice.py | 3 ++- edg/electronics_model/VoltagePorts.py | 14 ++++---------- edg/electronics_model/test_voltage_link.py | 11 +++++++++-- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/edg/electronics_model/VoltageDummyDevice.py b/edg/electronics_model/VoltageDummyDevice.py index 3bc1c0de9..8ca1c52a7 100644 --- a/edg/electronics_model/VoltageDummyDevice.py +++ b/edg/electronics_model/VoltageDummyDevice.py @@ -1,6 +1,6 @@ from .DummyDevice import DummyDevice from .VoltagePorts import VoltageSource, VoltageSink, Power -from ..core import RangeExpr, RangeLike, InOut +from ..core import BoolExpr, RangeExpr, RangeLike, InOut class DummyVoltageSource(DummyDevice): @@ -25,6 +25,7 @@ def __init__( self.current_drawn = self.Parameter(RangeExpr(self.pwr.link().current_drawn)) self.voltage_limits = self.Parameter(RangeExpr(self.pwr.link().voltage_limits)) + self.reverse_voltage = self.Parameter(RangeExpr(self.pwr.link().reverse_voltage)) class DummyVoltageSink(DummyDevice): diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index 5f72e6b24..a4ade4353 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -41,7 +41,6 @@ def __init__(self) -> None: self.current_drawn = self.Parameter(RangeExpr()) self.current_limits = self.Parameter(RangeExpr()) - self.has_reverse_voltage = self.Parameter(BoolExpr()) self.reverse_voltage = self.Parameter(RangeExpr()) self.reverse_voltage_limits = self.Parameter(RangeExpr()) self.reverse_current_drawn = self.Parameter(RangeExpr()) @@ -70,28 +69,23 @@ def contents(self) -> None: self.require(self.current_limits.contains(self.current_drawn), "current draw out of limits") # TODO limit to one reverse voltage source - self.assign(self.has_reverse_voltage, self.reverse_voltage != RangeExpr.EMPTY) + has_reverse_voltage = self.reverse_voltage != RangeExpr.EMPTY self.assign(self.reverse_voltage, self.sinks.hull(lambda x: x.reverse_voltage_out)) self.assign(self.reverse_voltage_limits, self.source.reverse_voltage_limits) # use implications to gate the reverse voltage requirements, since not all sources will support reverse voltage self.require( - self.has_reverse_voltage.implies(self.reverse_voltage_limits != RangeExpr.EMPTY), + has_reverse_voltage.implies(self.reverse_voltage_limits != RangeExpr.EMPTY), "reverse voltage source must have reverse voltage sink", ) self.require( - self.has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.reverse_voltage)), + has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.reverse_voltage)), "reverse voltage limits out of range", ) - # this is a heuristic check, assuming that each source is non-zero-volts - self.require( - self.has_reverse_voltage.implies(self.reverse_voltage == self.sinks.sum(lambda x: x.reverse_voltage_out)), - "may not have multiple reverse voltage sources", - ) self.assign(self.reverse_current_drawn, self.source.reverse_current_draw) self.assign(self.reverse_current_limits, self.sinks.hull(lambda x: x.reverse_current_limits)) self.require( - self.has_reverse_voltage.implies(self.reverse_current_limits.contains(self.reverse_current_drawn)), + has_reverse_voltage.implies(self.reverse_current_limits.contains(self.reverse_current_drawn)), "reverse current out of limits", ) diff --git a/edg/electronics_model/test_voltage_link.py b/edg/electronics_model/test_voltage_link.py index f73b206db..3ca627d26 100644 --- a/edg/electronics_model/test_voltage_link.py +++ b/edg/electronics_model/test_voltage_link.py @@ -66,7 +66,14 @@ def __init__(self) -> None: reverse_current_limits=(0, 1) * Amp, ) ) - self.connect(self.src.pwr, self.sink.pwr) + self.sink2 = self.Block( + DummyVoltageSink( + voltage_limit=5 * Volt(tol=0.1), + current_draw=0 * Amp, + ) + ) + self.connect(self.src.pwr, self.sink.pwr, self.sink2.pwr) + self.require(self.src.reverse_voltage == 5 * Volt(tol=0)) class ReverseMultiSourceTestTop(DesignTop): @@ -137,7 +144,7 @@ def test_overcurrent(self) -> None: def test_reverse_voltage(self) -> None: ScalaCompiler.compile(ReverseVoltageTestTop) - def test_reverse_mult_source(self) -> None: + def test_reverse_multi_source(self) -> None: with self.assertRaises(CompilerCheckError): ScalaCompiler.compile(ReverseMultiSourceTestTop) From f0ecd322ae68d08edb0a6320deef96d8b08a87b3 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 17:11:36 -0700 Subject: [PATCH 05/21] Update VoltagePorts.py --- edg/electronics_model/VoltagePorts.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index a4ade4353..1d71ad851 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -68,7 +68,6 @@ def contents(self) -> None: self.assign(self.current_drawn, self.sinks.sum(lambda x: x.current_draw)) self.require(self.current_limits.contains(self.current_drawn), "current draw out of limits") - # TODO limit to one reverse voltage source has_reverse_voltage = self.reverse_voltage != RangeExpr.EMPTY self.assign(self.reverse_voltage, self.sinks.hull(lambda x: x.reverse_voltage_out)) self.assign(self.reverse_voltage_limits, self.source.reverse_voltage_limits) @@ -81,6 +80,9 @@ def contents(self) -> None: has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.reverse_voltage)), "reverse voltage limits out of range", ) + self.require( + self.sinks.count(lambda x: x._is_reverse_voltage) <= 1, "multiple reverse voltage sources not allows" + ), self.assign(self.reverse_current_drawn, self.source.reverse_current_draw) self.assign(self.reverse_current_limits, self.sinks.hull(lambda x: x.reverse_current_limits)) @@ -177,6 +179,8 @@ def __init__( self.reverse_voltage_out: RangeExpr = self.Parameter(RangeExpr(reverse_voltage_out)) self.reverse_current_limits: RangeExpr = self.Parameter(RangeExpr(reverse_current_limits)) + # needed to check for multiple sinks, since we don't have arbitrary lambdas to do a map on reverse_voltage_out + self._is_reverse_voltage: BoolExpr = self.Parameter(BoolExpr(reverse_voltage_out != RangeExpr.EMPTY)) class VoltageSinkAdapterGroundReference(CircuitPortAdapter["GroundReference"]): From 845c49d4d28be2ea9f0cee68677fcb128c66c602 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 17:18:52 -0700 Subject: [PATCH 06/21] reverse checks --- edg/electronics_model/VoltagePorts.py | 14 ++++-- edg/electronics_model/test_voltage_link.py | 58 ++++++++++++++++++++++ 2 files changed, 69 insertions(+), 3 deletions(-) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index 1d71ad851..2d3dd931a 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -76,13 +76,21 @@ def contents(self) -> None: has_reverse_voltage.implies(self.reverse_voltage_limits != RangeExpr.EMPTY), "reverse voltage source must have reverse voltage sink", ) + self.require( + self.sinks.count(lambda x: x._is_reverse_voltage) <= 1, "multiple reverse voltage sources not allows" + ) self.require( has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.reverse_voltage)), - "reverse voltage limits out of range", + "reverse voltage out of range", ) self.require( - self.sinks.count(lambda x: x._is_reverse_voltage) <= 1, "multiple reverse voltage sources not allows" - ), + has_reverse_voltage.implies(self.voltage_limits.contains(self.reverse_voltage)), + "reverse voltage out of range of voltage limits", + ) + self.require( + has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.voltage)), + "voltage out of range of reverse voltage limits", + ) self.assign(self.reverse_current_drawn, self.source.reverse_current_draw) self.assign(self.reverse_current_limits, self.sinks.hull(lambda x: x.reverse_current_limits)) diff --git a/edg/electronics_model/test_voltage_link.py b/edg/electronics_model/test_voltage_link.py index 3ca627d26..45b864ad0 100644 --- a/edg/electronics_model/test_voltage_link.py +++ b/edg/electronics_model/test_voltage_link.py @@ -125,6 +125,56 @@ def __init__(self) -> None: self.connect(self.src.pwr, self.sink.pwr) +class ReverseOvervoltageTestTop(DesignTop): + """Test design with reverse voltage incompatibility""" + + def __init__(self) -> None: + super().__init__() + self.src = self.Block( + DummyVoltageSource( + voltage_out=3.3 * Volt(tol=0), + current_limits=(0, 1) * Amp, + reverse_voltage_limits=3.3 * Volt(tol=0.1), + reverse_current_draw=0 * Amp, + ) + ) + self.sink = self.Block( + DummyVoltageSink( + voltage_limit=(0, 14) * Volt, + current_draw=0 * Amp, + reverse_voltage_out=5 * Volt(tol=0), + reverse_current_limits=(0, 1) * Amp, + ) + ) + self.connect(self.src.pwr, self.sink.pwr) + self.require(self.src.reverse_voltage != RangeExpr.EMPTY) + + +class ReverseForwardOvervoltageTestTop(DesignTop): + """Test design with reverse voltage incompatibility with forward limits""" + + def __init__(self) -> None: + super().__init__() + self.src = self.Block( + DummyVoltageSource( + voltage_out=5 * Volt(tol=0), + current_limits=(0, 1) * Amp, + reverse_voltage_limits=(0, 14) * Volt, + reverse_current_draw=0 * Amp, + ) + ) + self.sink = self.Block( + DummyVoltageSink( + voltage_limit=5 * Volt(tol=0.1), + current_draw=0 * Amp, + reverse_voltage_out=12 * Volt(tol=0), + reverse_current_limits=(0, 1) * Amp, + ) + ) + self.connect(self.src.pwr, self.sink.pwr) + self.require(self.src.reverse_voltage != RangeExpr.EMPTY) + + class VoltageLinkTestCase(unittest.TestCase): def test_voltage(self) -> None: ScalaCompiler.compile(VoltageTestTop) @@ -151,3 +201,11 @@ def test_reverse_multi_source(self) -> None: def test_reverse_no_sink(self) -> None: with self.assertRaises(CompilerCheckError): ScalaCompiler.compile(ReverseNoSinkTest) + + def test_reverse_overvoltage(self) -> None: + with self.assertRaises(CompilerCheckError): + ScalaCompiler.compile(ReverseOvervoltageTestTop) + + def test_reverse_forward_overvoltage(self) -> None: + with self.assertRaises(CompilerCheckError): + ScalaCompiler.compile(ReverseForwardOvervoltageTestTop) From 70e734bc8a0c96c1ddb3a6738e0ec4d19276b905 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 18:22:15 -0700 Subject: [PATCH 07/21] bool negate set op --- .../src/main/scala/edg/compiler/ExprEvaluate.scala | 2 ++ .../test/scala/edg/compiler/ExprEvaluateTest.scala | 11 +++++++++++ 2 files changed, 13 insertions(+) diff --git a/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala b/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala index 2d53cd4ab..08c927795 100644 --- a/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala +++ b/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala @@ -363,6 +363,8 @@ object ExprEvaluate { evalUnary(expr.UnaryExpr(op = expr.UnaryExpr.Op.NEGATE), arrayElt) } ArrayValue(resultElts) + case ArrayValue.ExtractBoolean(arrayElts) => + ArrayValue(arrayElts.map { arrayElt => BooleanValue(!arrayElt) }) case _ => throw new ExprEvaluateException(s"Unknown unary set operand in ${unarySet.op} $vals from $unarySet") } diff --git a/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala b/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala index 1667a507d..6a38fed22 100644 --- a/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala +++ b/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala @@ -300,6 +300,17 @@ class ExprEvaluateTest extends AnyFlatSpec { it should "handle array unary set ops" in { import edg.ExprBuilder.Literal import edgir.expr.expr.UnarySetExpr.Op + evalTest.map( + ValueExpr.UnarySetOp( + Op.NEGATE, + ValueExpr.Literal(Seq( + Literal.Boolean(false), + Literal.Boolean(true), + Literal.Boolean(false), + )) + ) + ) should equal(ArrayValue(Seq(BooleanValue(true), BooleanValue(false), BooleanValue(true)))) + evalTest.map( ValueExpr.UnarySetOp( Op.FLATTEN, From cf1dd59fd3e4f33dc3ce3866d3e05e0d6361ba95 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 18:41:04 -0700 Subject: [PATCH 08/21] Add set-element EQ --- compiler/src/main/scala/edg/ExprBuilder.scala | 9 + .../scala/edg/compiler/ExprEvaluate.scala | 10 + .../scala/edg/compiler/ExprToString.scala | 3 +- .../scala/edg/compiler/ExprEvaluateTest.scala | 15 + .../resources/edg-compiler-precompiled.jar | Bin 13118227 -> 13120322 bytes edg/edgir/common_pb2.py | 12 +- edg/edgir/common_pb2.pyi | 205 ++--- edg/edgir/elem_pb2.py | 13 +- edg/edgir/elem_pb2.pyi | 619 +++++++-------- edg/edgir/expr_pb2.py | 59 +- edg/edgir/expr_pb2.pyi | 724 ++++++++---------- edg/edgir/impl_pb2.py | 11 +- edg/edgir/impl_pb2.pyi | 68 +- edg/edgir/init_pb2.py | 11 +- edg/edgir/init_pb2.pyi | 124 ++- edg/edgir/lit_pb2.py | 13 +- edg/edgir/lit_pb2.pyi | 209 +++-- edg/edgir/name_pb2.py | 11 +- edg/edgir/name_pb2.pyi | 45 +- edg/edgir/ref_pb2.py | 11 +- edg/edgir/ref_pb2.pyi | 128 ++-- edg/edgir/schema_pb2.py | 13 +- edg/edgir/schema_pb2.pyi | 171 ++--- edg/edgrpc/compiler_pb2.py | 11 +- edg/edgrpc/compiler_pb2.pyi | 113 +-- edg/edgrpc/hdl_pb2.py | 13 +- edg/edgrpc/hdl_pb2.pyi | 599 +++++++-------- proto/edgir/expr.proto | 4 + 28 files changed, 1442 insertions(+), 1782 deletions(-) diff --git a/compiler/src/main/scala/edg/ExprBuilder.scala b/compiler/src/main/scala/edg/ExprBuilder.scala index 4b2ef1756..abd55b7f3 100644 --- a/compiler/src/main/scala/edg/ExprBuilder.scala +++ b/compiler/src/main/scala/edg/ExprBuilder.scala @@ -133,6 +133,15 @@ object ExprBuilder { ) } + def RangeEmpty(): lit.ValueLit = { + lit.ValueLit(`type` = + lit.ValueLit.Type.Range(lit.RangeLit( + minimum = Some(Floating(Float.NaN)), + maximum = Some(Floating(Float.NaN)) + )) + ) + } + def Array(values: Seq[lit.ValueLit]): lit.ValueLit = { lit.ValueLit(`type` = lit.ValueLit.Type.Array(lit.ArrayLit( diff --git a/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala b/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala index 08c927795..d06f4a90e 100644 --- a/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala +++ b/compiler/src/main/scala/edg/compiler/ExprEvaluate.scala @@ -224,6 +224,16 @@ object ExprEvaluate { binarySet.op match { // Note promotion rules: range takes precedence, then float, then int // TODO: can we deduplicate these cases to delegate them to evalBinary? + case Op.EQ => (lhs, rhs) match { + case (lhss: ArrayValue[ExprValue] @unchecked, rhs: ExprValue) => + val resultElts = lhss.values.map { arrayElt => + evalBinary(expr.BinaryExpr(op = expr.BinaryExpr.Op.EQ), arrayElt, rhs) + } + ArrayValue(resultElts) + case _ => throw new ExprEvaluateException( + s"Unknown binary set operand types in $lhs ${binarySet.op} $rhs from $binarySet" + ) + } case Op.ADD => (lhs, rhs) match { case (ArrayValue.ExtractRange(arrayElts), rhs: RangeType) => val resultElts = arrayElts.map { arrayElt => diff --git a/compiler/src/main/scala/edg/compiler/ExprToString.scala b/compiler/src/main/scala/edg/compiler/ExprToString.scala index 794dd5501..1c622a38b 100644 --- a/compiler/src/main/scala/edg/compiler/ExprToString.scala +++ b/compiler/src/main/scala/edg/compiler/ExprToString.scala @@ -82,6 +82,7 @@ class ExprToString() extends ValueExprMap[String] { import expr.BinarySetExpr.Op object InfixOp { def unapply(op: Op): Option[String] = op match { + case Op.EQ => Some("==") case Op.ADD => Some("+") case Op.MULT => Some("×") case Op.CONCAT => None @@ -91,7 +92,7 @@ class ExprToString() extends ValueExprMap[String] { object PrefixOp { def unapply(op: Op): Option[String] = op match { case Op.CONCAT => Some("concat") - case Op.ADD | Op.MULT => None + case Op.EQ | Op.ADD | Op.MULT => None case Op.UNDEFINED | Op.Unrecognized(_) => None } } diff --git a/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala b/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala index 6a38fed22..3c09f2bed 100644 --- a/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala +++ b/compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala @@ -338,6 +338,21 @@ class ExprEvaluateTest extends AnyFlatSpec { it should "handle array-value (broadcast) ops" in { import edg.ExprBuilder.Literal import edgir.expr.expr.BinarySetExpr.Op + evalTest.map( + ValueExpr.BinSetOp( + Op.EQ, + ValueExpr.Literal(Seq(Literal.Range(0, 10), Literal.Range(1, 11))), + ValueExpr.Literal(0, 10) + ) + ) should equal(ArrayValue(Seq(BooleanValue(true), BooleanValue(false)))) + evalTest.map( + ValueExpr.BinSetOp( + Op.EQ, + ValueExpr.Literal(Seq(Literal.Range(0, 10), Literal.RangeEmpty())), + ValueExpr.LiteralRangeEmpty() + ) + ) should equal(ArrayValue(Seq(BooleanValue(false), BooleanValue(true)))) + evalTest.map( ValueExpr.BinSetOp( Op.ADD, diff --git a/edg/core/resources/edg-compiler-precompiled.jar b/edg/core/resources/edg-compiler-precompiled.jar index 5aa815ab505b8dfca3273b5c419d732cfd2879f7..64d35124043e0901dc0ff9d336c5bd67249ee443 100644 GIT binary patch delta 165168 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ϒio+(fDQPxm@r@o=7nLbq8}9%DIAv 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 z zHRE2!uS%=nQUfIJ%^N{No*%_ADuzfv_xB31q5PLfSN>hZ^r|7kdtwt{!@}WGyXySg zfEF6T#W)uhoamN)o)KNN#eze={$L73RY(pU?h-3LEg_u*3t)VtIPqOv9U+9e~9^ug8h>3i= zTugymV$WU1BTNf%u+dy0^q^)IPgp`GI5co2dEAyPhTFgi@1T@{GVDuBs3R_6u zupzG2(3o3?9mvx!uh3%vvhZVzWIFf_Q(h))K^Yfi!b{uPDEf6aA zsK8~mh1EozhYC(x*z_%7&@BJ|FwhpeAkOXCY;~jf|FDwlL+r%I26+$vPXqs3xR_iX z`&hwh zHHa-mmEsY&Y>!Yocgt9={@fFe;aFG)6v%&5eo(n?!u~ax3_Q6CvZHSf2-x9~AcdC4 zvB8)l$kAs^94W#PF}1D`!hOfW<|+pl%=hYW)B)2&3iYVDQ=yN_t9Cw3bIG@-a3@r8 ztLo&_Mb~^gG4yxY3EmR0ag9@9TS>PC^>!=7*$dSRak^1;xON?{5G&eU9hFRo*x zz==Jbb1iHxm188A1t+({X3~_4EDVsIUgKX|I_8F3YL5f3wSqp?2|*j$(;Z%pKM}b4 zy?itADgSrI$DRx9@Ce5N$)7Y&GVb+J;60_Vo_`J%n3V_cMr{AWzMsE^bx#kJfEW67 zsWwu$(F4h?FjfR(dgXyEEwvM*t3`o1z2GsJzBS;d6kj(uR9EW)Gx91z1|%|GUPs{j zuCSH|3*R!%!NOd&1~#C2HQ^SgLCWM+!vYJM$md6Gt_i~;KY_h{3rwh}CZd<$l1XiH zuZ2(-dkeuY7>gj+)q=XTk05tz;UOG0kcB!FSQ}Yu94dtEwF{d{e~xBhr1X89FrPRA z{ttgRZACNd6go;1FtwB~Vp+FPmk!rKL3709Q7vgIt-@dc3%}OI(;GZr5iBBm;(R)J z3!eY#BK98^(R5F|4+A~nA!RuWLnVjR{Oe7hJn?Lv+bDzqUa;`PUdOfZ`cCsg(vs3x zaHJmIDE%u8FxKJV4VS~Q{6UMceSZ!McJ$i2(2#a{!$mp91hmA?{EE#Ln_XiK{n K!TGgaw2Kga?EOgb9QSgbRcWgbjoagb#!egb{=i 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 RIPo6Ed@M6g8V3v*@E Date: Sun, 29 Mar 2026 21:38:24 -0700 Subject: [PATCH 10/21] Update VoltagePorts.py --- edg/electronics_model/VoltagePorts.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index 2d3dd931a..ffbec3b8f 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -77,8 +77,17 @@ def contents(self) -> None: "reverse voltage source must have reverse voltage sink", ) self.require( - self.sinks.count(lambda x: x._is_reverse_voltage) <= 1, "multiple reverse voltage sources not allows" + ( + ~( + self.sinks.map_extract(lambda x: x.reverse_voltage_out).elts_equals( + RangeExpr._to_expr_type(RangeExpr.EMPTY) + ) + ) + ).count() + <= 1, + "multiple reverse voltage sinks not allowed", ) + self.require( has_reverse_voltage.implies(self.reverse_voltage_limits.contains(self.reverse_voltage)), "reverse voltage out of range", @@ -187,8 +196,6 @@ def __init__( self.reverse_voltage_out: RangeExpr = self.Parameter(RangeExpr(reverse_voltage_out)) self.reverse_current_limits: RangeExpr = self.Parameter(RangeExpr(reverse_current_limits)) - # needed to check for multiple sinks, since we don't have arbitrary lambdas to do a map on reverse_voltage_out - self._is_reverse_voltage: BoolExpr = self.Parameter(BoolExpr(reverse_voltage_out != RangeExpr.EMPTY)) class VoltageSinkAdapterGroundReference(CircuitPortAdapter["GroundReference"]): From f8109ca8a9637905947d71d92b5e2035c6eb342f Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 21:41:26 -0700 Subject: [PATCH 11/21] cleaning --- edg/core/ArrayExpr.py | 10 +++++----- edg/electronics_model/VoltagePorts.py | 9 +-------- 2 files changed, 6 insertions(+), 13 deletions(-) diff --git a/edg/core/ArrayExpr.py b/edg/core/ArrayExpr.py index 6c5c221bd..2197e6c27 100644 --- a/edg/core/ArrayExpr.py +++ b/edg/core/ArrayExpr.py @@ -128,11 +128,6 @@ def intersection(self) -> ArrayEltType: def hull(self) -> ArrayEltType: return self._create_unary_set_op(RangeSetOp.hull) - def elts_equals(self, other: ConstraintExpr[Any, None]) -> ArrayBoolExpr: - """Returns an ArrayBoolExpr of equality between each element of this and single-element other.""" - assert self._is_bound() and other._is_bound() - return ArrayBoolExpr()._new_bind(BinarySetOpBinding(self, other, EqOp.all_equal)) - ArrayBoolLike = Union["ArrayBoolExpr", Sequence[BoolLike]] @@ -187,6 +182,11 @@ def __rtruediv__(self, other: Union[FloatLike, RangeLike]) -> ArrayRangeExpr: self._create_unary_set_op(NumericOp.invert), RangeExpr._to_expr_type(other), NumericOp.mul ) + def elts_equals(self, other: RangeExpr) -> ArrayBoolExpr: + """Returns an ArrayBoolExpr of equality between each element of this and single-element other. + TODO: generalize to equality for other array types, needs some generic version of _to_expr_type""" + return ArrayBoolExpr()._new_bind(BinarySetOpBinding(self, RangeExpr._to_expr_type(other), EqOp.all_equal)) + ArrayStringLike = Union["ArrayStringExpr", Sequence[StringLike]] diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index ffbec3b8f..078b5b8f2 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -77,14 +77,7 @@ def contents(self) -> None: "reverse voltage source must have reverse voltage sink", ) self.require( - ( - ~( - self.sinks.map_extract(lambda x: x.reverse_voltage_out).elts_equals( - RangeExpr._to_expr_type(RangeExpr.EMPTY) - ) - ) - ).count() - <= 1, + (~(self.sinks.map_extract(lambda x: x.reverse_voltage_out).elts_equals(RangeExpr.EMPTY))).count() <= 1, "multiple reverse voltage sinks not allowed", ) From 2e6df2f304164e29a791dd1e964d85615553b0fd Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 21:51:18 -0700 Subject: [PATCH 12/21] type clean --- edg/core/ArrayExpr.py | 2 +- edg/electronics_model/test_voltage_link.py | 22 +++++++++++----------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/edg/core/ArrayExpr.py b/edg/core/ArrayExpr.py index 2197e6c27..cbacebad7 100644 --- a/edg/core/ArrayExpr.py +++ b/edg/core/ArrayExpr.py @@ -182,7 +182,7 @@ def __rtruediv__(self, other: Union[FloatLike, RangeLike]) -> ArrayRangeExpr: self._create_unary_set_op(NumericOp.invert), RangeExpr._to_expr_type(other), NumericOp.mul ) - def elts_equals(self, other: RangeExpr) -> ArrayBoolExpr: + def elts_equals(self, other: RangeLike) -> ArrayBoolExpr: """Returns an ArrayBoolExpr of equality between each element of this and single-element other. TODO: generalize to equality for other array types, needs some generic version of _to_expr_type""" return ArrayBoolExpr()._new_bind(BinarySetOpBinding(self, RangeExpr._to_expr_type(other), EqOp.all_equal)) diff --git a/edg/electronics_model/test_voltage_link.py b/edg/electronics_model/test_voltage_link.py index 45b864ad0..9b3d06153 100644 --- a/edg/electronics_model/test_voltage_link.py +++ b/edg/electronics_model/test_voltage_link.py @@ -55,13 +55,13 @@ def __init__(self) -> None: voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp, reverse_voltage_limits=5 * Volt(tol=0.1), - reverse_current_draw=0 * Amp, + reverse_current_draw=0 * Amp(tol=0), ) ) self.sink = self.Block( DummyVoltageSink( voltage_limit=5 * Volt(tol=0.1), - current_draw=0 * Amp, + current_draw=0 * Amp(tol=0), reverse_voltage_out=5 * Volt(tol=0), reverse_current_limits=(0, 1) * Amp, ) @@ -69,7 +69,7 @@ def __init__(self) -> None: self.sink2 = self.Block( DummyVoltageSink( voltage_limit=5 * Volt(tol=0.1), - current_draw=0 * Amp, + current_draw=0 * Amp(tol=0), ) ) self.connect(self.src.pwr, self.sink.pwr, self.sink2.pwr) @@ -86,13 +86,13 @@ def __init__(self) -> None: voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp, reverse_voltage_limits=5 * Volt(tol=0.1), - reverse_current_draw=0 * Amp, + reverse_current_draw=0 * Amp(tol=0), ) ) self.sink1 = self.Block( DummyVoltageSink( voltage_limit=5 * Volt(tol=0.1), - current_draw=0 * Amp, + current_draw=0 * Amp(tol=0), reverse_voltage_out=5 * Volt(tol=0), reverse_current_limits=(0, 1) * Amp, ) @@ -100,7 +100,7 @@ def __init__(self) -> None: self.sink2 = self.Block( DummyVoltageSink( voltage_limit=5 * Volt(tol=0.1), - current_draw=0 * Amp, + current_draw=0 * Amp(tol=0), reverse_voltage_out=5 * Volt(tol=0), reverse_current_limits=(0, 1) * Amp, ) @@ -117,7 +117,7 @@ def __init__(self) -> None: self.sink = self.Block( DummyVoltageSink( voltage_limit=5 * Volt(tol=0.1), - current_draw=0 * Amp, + current_draw=0 * Amp(tol=0), reverse_voltage_out=5 * Volt(tol=0), reverse_current_limits=(0, 1) * Amp, ) @@ -135,13 +135,13 @@ def __init__(self) -> None: voltage_out=3.3 * Volt(tol=0), current_limits=(0, 1) * Amp, reverse_voltage_limits=3.3 * Volt(tol=0.1), - reverse_current_draw=0 * Amp, + reverse_current_draw=0 * Amp(tol=0), ) ) self.sink = self.Block( DummyVoltageSink( voltage_limit=(0, 14) * Volt, - current_draw=0 * Amp, + current_draw=0 * Amp(tol=0), reverse_voltage_out=5 * Volt(tol=0), reverse_current_limits=(0, 1) * Amp, ) @@ -160,13 +160,13 @@ def __init__(self) -> None: voltage_out=5 * Volt(tol=0), current_limits=(0, 1) * Amp, reverse_voltage_limits=(0, 14) * Volt, - reverse_current_draw=0 * Amp, + reverse_current_draw=0 * Amp(tol=0), ) ) self.sink = self.Block( DummyVoltageSink( voltage_limit=5 * Volt(tol=0.1), - current_draw=0 * Amp, + current_draw=0 * Amp(tol=0), reverse_voltage_out=12 * Volt(tol=0), reverse_current_limits=(0, 1) * Amp, ) From f2449956e553ac809742d104096fcaf2931147ec Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 22:18:24 -0700 Subject: [PATCH 13/21] add reverse to bridges, refactor pcbbot and charger example --- edg/electronics_model/VoltagePorts.py | 42 ++++++++++++++++++++++++--- edg/parts/BatteryCharger_Mcp73831.py | 6 ++-- edg/parts/Connectors.py | 23 +++++++++++---- examples/test_pcbbot.py | 2 +- 4 files changed, 59 insertions(+), 14 deletions(-) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index 078b5b8f2..f46c6a089 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -106,13 +106,27 @@ class VoltageSinkBridge(CircuitPortBridge): def __init__(self) -> None: super().__init__() - self.outer_port = self.Port(VoltageSink(current_draw=RangeExpr(), voltage_limits=RangeExpr())) + self.outer_port = self.Port( + VoltageSink( + current_draw=RangeExpr(), + voltage_limits=RangeExpr(), + reverse_voltage_out=RangeExpr(), + reverse_current_limits=RangeExpr(), + ) + ) # Here we ignore the current_limits of the inner port, instead relying on the main link to handle it # The outer port's voltage_limits is untouched and should be defined in the port def. # TODO: it's a slightly optimization to handle them here. Should it be done? # TODO: or maybe current_limits / voltage_limits shouldn't be a port, but rather a block property? - self.inner_link = self.Port(VoltageSource(current_limits=RangeExpr.ALL, voltage_out=RangeExpr())) + self.inner_link = self.Port( + VoltageSource( + current_limits=RangeExpr.ALL, + voltage_out=RangeExpr(), + reverse_voltage_limits=RangeExpr.ALL, + reverse_current_draw=RangeExpr(), + ) + ) @override def contents(self) -> None: @@ -120,21 +134,38 @@ def contents(self) -> None: self.assign(self.outer_port.current_draw, self.inner_link.link().current_drawn) self.assign(self.outer_port.voltage_limits, self.inner_link.link().voltage_limits) + self.assign(self.outer_port.reverse_voltage_out, self.inner_link.link().reverse_voltage) + self.assign(self.outer_port.reverse_current_limits, self.inner_link.link().reverse_current_limits) self.assign(self.inner_link.voltage_out, self.outer_port.link().voltage) + self.assign(self.inner_link.reverse_current_draw, self.outer_port.link().reverse_current_drawn) class VoltageSourceBridge(CircuitPortBridge): # basic passthrough port, sources look the same inside and outside def __init__(self) -> None: super().__init__() - self.outer_port = self.Port(VoltageSource(voltage_out=RangeExpr(), current_limits=RangeExpr())) + self.outer_port = self.Port( + VoltageSource( + voltage_out=RangeExpr(), + current_limits=RangeExpr(), + reverse_voltage_limits=RangeExpr(), + reverse_current_draw=RangeExpr(), + ) + ) # Here we ignore the voltage_limits of the inner port, instead relying on the main link to handle it # The outer port's current_limits is untouched and should be defined in tte port def. # TODO: it's a slightly optimization to handle them here. Should it be done? # TODO: or maybe current_limits / voltage_limits shouldn't be a port, but rather a block property? - self.inner_link = self.Port(VoltageSink(voltage_limits=RangeExpr.ALL, current_draw=RangeExpr())) + self.inner_link = self.Port( + VoltageSink( + voltage_limits=RangeExpr.ALL, + current_draw=RangeExpr(), + reverse_voltage_out=RangeExpr(), + reverse_current_limits=RangeExpr.ALL, + ) + ) @override def contents(self) -> None: @@ -144,8 +175,11 @@ def contents(self) -> None: self.assign( self.outer_port.current_limits, self.inner_link.link().current_limits ) # TODO adjust for inner current drawn + self.assign(self.outer_port.reverse_voltage_limits, self.inner_link.link().reverse_voltage_limits) + self.assign(self.outer_port.reverse_current_draw, self.inner_link.link().reverse_current_drawn) self.assign(self.inner_link.current_draw, self.outer_port.link().current_drawn) + self.assign(self.inner_link.reverse_voltage_out, self.outer_port.link().reverse_voltage) class VoltageBase(CircuitPort[VoltageLink]): diff --git a/edg/parts/BatteryCharger_Mcp73831.py b/edg/parts/BatteryCharger_Mcp73831.py index 8f97238c4..68269355d 100644 --- a/edg/parts/BatteryCharger_Mcp73831.py +++ b/edg/parts/BatteryCharger_Mcp73831.py @@ -22,9 +22,9 @@ def __init__(self, actual_charging_current: RangeLike) -> None: DigitalSource.from_supply(self.vss, self.vdd, current_limits=(-25, 35) * mAmp), optional=True ) self.vbat = self.Port( - VoltageSource( - voltage_out=(4.168, 4.232) * Volt, # -2 variant - current_limits=self.actual_charging_current.hull(0 * Amp(tol=0)), + VoltageSink( + reverse_voltage_out=(4.168, 4.232) * Volt, # -2 variant + reverse_current_limits=self.actual_charging_current.hull(0 * Amp(tol=0)), ) ) self.prog = self.Port(Passive()) diff --git a/edg/parts/Connectors.py b/edg/parts/Connectors.py index 2c239c6e2..f37e31f1f 100644 --- a/edg/parts/Connectors.py +++ b/edg/parts/Connectors.py @@ -1,3 +1,4 @@ +import warnings from typing import Any from typing_extensions import override @@ -71,17 +72,28 @@ class LipoConnector(Connector, Battery): Connector type not specified, up to the user through a refinement.""" + def __getattr__(self, item: str) -> Any: + if item == "chg": + warnings.warn( + f"pwr is sink-capable (bidirectional) and chg is no longer needed", + DeprecationWarning, + stacklevel=2, + ) + return self.pwr + else: + raise AttributeError( + item + ) # ideally we'd use super().__getattr__(...), but that's not defined in base classes + def __init__( self, voltage: RangeLike = (2.5, 4.2) * Volt, *args: Any, actual_voltage: RangeLike = (2.5, 4.2) * Volt, + charge_voltage: RangeLike = (2.5, 4.2 * 1.01) * Volt, **kwargs: Any, ) -> None: - from ..electronics_model.PassivePort import PassiveAdapterVoltageSink - super().__init__(voltage, *args, **kwargs) - self.chg = self.Port(VoltageSink.empty(), optional=True) # ideal port for charging self.conn = self.Block(PassiveConnector()) self.connect(self.gnd, self.conn.pins.request("1").adapt_to(Ground())) @@ -92,12 +104,11 @@ def __init__( VoltageSource( voltage_out=actual_voltage, # arbitrary from https://www.mouser.com/catalog/additional/Adafruit_3262.pdf current_limits=(0, 5.5) * Amp, # arbitrary assuming low capacity, 10 C discharge + reverse_voltage_limits=charge_voltage, + reverse_current_draw=(0, 0) * Amp, ) ), ) - self.chg_adapter = self.Block(PassiveAdapterVoltageSink()) - self.connect(pwr_pin, self.chg_adapter.src) - self.connect(self.chg, self.chg_adapter.dst) self.assign(self.actual_capacity, (500, 600) * mAmp) # arbitrary diff --git a/examples/test_pcbbot.py b/examples/test_pcbbot.py index 406b181c4..56fca98b3 100644 --- a/examples/test_pcbbot.py +++ b/examples/test_pcbbot.py @@ -71,7 +71,7 @@ def contents(self) -> None: ) self.v3v3 = self.connect(self.reg_3v3.pwr_out) - (self.charger,), _ = self.chain(self.vusb, imp.Block(Mcp73831(200 * mAmp(tol=0.2))), self.batt.chg) + (self.charger,), _ = self.chain(self.vusb, imp.Block(Mcp73831(200 * mAmp(tol=0.2))), self.batt.pwr) (self.charge_led,), _ = self.chain(self.Block(IndicatorSinkLed(Led.Yellow)), self.charger.stat) self.connect(self.vusb, self.charge_led.pwr) From 5f41512e1c80a6cc6d12a63d8159f7d711fe8f89 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 22:25:30 -0700 Subject: [PATCH 14/21] better charge tolerance definition --- edg/parts/Connectors.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/edg/parts/Connectors.py b/edg/parts/Connectors.py index f37e31f1f..8294c5d14 100644 --- a/edg/parts/Connectors.py +++ b/edg/parts/Connectors.py @@ -90,7 +90,7 @@ def __init__( voltage: RangeLike = (2.5, 4.2) * Volt, *args: Any, actual_voltage: RangeLike = (2.5, 4.2) * Volt, - charge_voltage: RangeLike = (2.5, 4.2 * 1.01) * Volt, + charge_tolerance: RangeLike = (1.0, 1.01) * Ratio, **kwargs: Any, ) -> None: super().__init__(voltage, *args, **kwargs) @@ -104,7 +104,7 @@ def __init__( VoltageSource( voltage_out=actual_voltage, # arbitrary from https://www.mouser.com/catalog/additional/Adafruit_3262.pdf current_limits=(0, 5.5) * Amp, # arbitrary assuming low capacity, 10 C discharge - reverse_voltage_limits=charge_voltage, + reverse_voltage_limits=actual_voltage * RangeExpr._to_expr_type(charge_tolerance), reverse_current_draw=(0, 0) * Amp, ) ), From 08189b04744939da6ff6a4e3cbd4528c6df7a25f Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Mon, 30 Mar 2026 00:17:32 -0700 Subject: [PATCH 15/21] propagate reverse voltages --- edg/parts/Connectors.py | 2 +- edg/parts/PowerConditioning.py | 62 +++++++++++++++++++----------- examples/test_protected_charger.py | 3 +- 3 files changed, 41 insertions(+), 26 deletions(-) diff --git a/edg/parts/Connectors.py b/edg/parts/Connectors.py index 8294c5d14..a7ae6ea12 100644 --- a/edg/parts/Connectors.py +++ b/edg/parts/Connectors.py @@ -75,7 +75,7 @@ class LipoConnector(Connector, Battery): def __getattr__(self, item: str) -> Any: if item == "chg": warnings.warn( - f"pwr is sink-capable (bidirectional) and chg is no longer needed", + f"Use pwr instead. pwr is sink-capable (bidirectional) and chg is unnecessary.", DeprecationWarning, stacklevel=2, ) diff --git a/edg/parts/PowerConditioning.py b/edg/parts/PowerConditioning.py index 24b688707..72a41a77b 100644 --- a/edg/parts/PowerConditioning.py +++ b/edg/parts/PowerConditioning.py @@ -1,4 +1,5 @@ -from typing import Optional, cast +import warnings +from typing import Optional, cast, Any from typing_extensions import override @@ -366,6 +367,26 @@ class PmosChargerReverseProtection(PowerConditioner, KiCadSchematicBlock, Block) More info at: https://www.edn.com/reverse-voltage-protection-for-battery-chargers/ """ + def __getattr__(self, item: str) -> Any: + if item == "chg_in": + warnings.warn( + f"Use pwr_out instead. pwr_out is sink-capable (bidirectional) and chg_in is unnecessary.", + DeprecationWarning, + stacklevel=2, + ) + return self.pwr_out + elif item == "chg_out": + warnings.warn( + f"Use pwr_in instead. pwr_in is source-capable (bidirectional) and chg_out is unnecessary.", + DeprecationWarning, + stacklevel=2, + ) + return self.pwr_out + else: + raise AttributeError( + item + ) # ideally we'd use super().__getattr__(...), but that's not defined in base classes + def __init__( self, r1_val: RangeLike = 100 * kOhm(tol=0.01), @@ -375,15 +396,12 @@ def __init__( super().__init__() self.gnd = self.Port(Ground.empty(), [Common]) + self.pwr_in = self.Port(VoltageSink.empty(), [Input], doc="Power input from the battery") + self.pwr_out = self.Port( - VoltageSource.empty(), doc="Power output for a load which will be also reverse protected from the battery" - ) - self.pwr_in = self.Port(VoltageSink.empty(), doc="Power input from the battery") - self.chg_in = self.Port( - VoltageSink.empty(), doc="Charger input to charge the battery. Must be connected to pwr_out." - ) - self.chg_out = self.Port( - VoltageSource.empty(), doc="Charging output to the battery chg port. Must be connected to pwr_in," + VoltageSource.empty(), + [Output], + doc="Power output for a load which will be also reverse protected from the battery", ) self.r1_val = self.ArgParameter(r1_val) @@ -396,10 +414,10 @@ def contents(self) -> None: self.r1 = self.Block(Resistor(resistance=self.r1_val)) self.r2 = self.Block(Resistor(resistance=self.r2_val)) - batt_voltage = self.pwr_in.link().voltage.hull(self.chg_in.link().voltage) + batt_voltage = self.pwr_in.link().voltage.hull(self.pwr_out.link().reverse_voltage) # taking the max of the current for the both direction. 0 lower bound - batt_current = self.pwr_out.link().current_drawn.hull(self.chg_out.link().current_drawn).hull((0, 0)) + batt_current = self.pwr_out.link().current_drawn.hull(self.pwr_in.link().reverse_current_drawn) power = batt_current * batt_current * self.rds_on r1_current = batt_voltage / self.r1.resistance @@ -422,21 +440,19 @@ def contents(self) -> None: ) ) - chg_in_adapter = self.Block(PassiveAdapterVoltageSink()) - setattr(self, "(adapter)chg_in", chg_in_adapter) # hack so the netlister recognizes this as an adapter - self.connect(self.mp1.source, chg_in_adapter.src) - self.connect(self.chg_in, chg_in_adapter.dst) - - chg_out_adapter = self.Block(PassiveAdapterVoltageSource()) - setattr(self, "(adapter)chg_out", chg_out_adapter) # hack so the netlister recognizes this as an adapter - self.connect(self.r2.b, chg_out_adapter.src) - self.connect(self.chg_out, chg_out_adapter.dst) - self.import_kicad( self.file_path("resources", f"{self.__class__.__name__}.kicad_sch"), conversions={ - "pwr_in": VoltageSink(current_draw=batt_current), - "pwr_out": VoltageSource(voltage_out=batt_voltage), + "pwr_in": VoltageSink( + current_draw=batt_current, + reverse_voltage_out=self.pwr_out.link().reverse_voltage, + reverse_current_limits=RangeExpr.ALL, + ), + "pwr_out": VoltageSource( + voltage_out=batt_voltage, + reverse_voltage_limits=RangeExpr.ALL, + reverse_current_draw=self.pwr_in.link().reverse_current_drawn, + ), "gnd": Ground(), }, ) diff --git a/examples/test_protected_charger.py b/examples/test_protected_charger.py index 3d2123897..ce290503b 100644 --- a/examples/test_protected_charger.py +++ b/examples/test_protected_charger.py @@ -31,9 +31,8 @@ def contents(self) -> None: self.tp = self.Block(VoltageTestPoint()).connected(self.batt.pwr) self.pmos = imp.Block(PmosChargerReverseProtection()) - (self.charger,), _ = self.chain(self.vusb, imp.Block(Mcp73831(200 * mAmp(tol=0.2))), self.pmos.chg_in) + (self.charger,), _ = self.chain(self.vusb, imp.Block(Mcp73831(200 * mAmp(tol=0.2))), self.pmos.pwr_out) self.connect(self.pmos.pwr_in, self.batt.pwr) - self.connect(self.pmos.chg_out, self.batt.chg) (self.charge_led,), _ = self.chain(self.Block(IndicatorSinkLed(Led.Yellow)), self.charger.stat) self.connect(self.vusb, self.charge_led.pwr) From ebf42f227b52a45a727af2b520db308efa70cd5d Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Mon, 30 Mar 2026 00:23:21 -0700 Subject: [PATCH 16/21] improve docs --- edg/parts/PowerConditioning.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/edg/parts/PowerConditioning.py b/edg/parts/PowerConditioning.py index 72a41a77b..d1aa42872 100644 --- a/edg/parts/PowerConditioning.py +++ b/edg/parts/PowerConditioning.py @@ -318,6 +318,7 @@ def connected_from( class PmosReverseProtection(PowerConditioner, KiCadSchematicBlock, Block): """Reverse polarity protection using a PMOS. This method has lower power loss over diode-based protection. 100R-330R is good but 1k-50k can be used for continuous load. + Not reverse / bidirectional current flow capable (eg, can't charge a battery through this). Ref: https://components101.com/articles/design-guide-pmos-mosfet-for-reverse-voltage-polarity-protection """ @@ -361,8 +362,11 @@ def contents(self) -> None: class PmosChargerReverseProtection(PowerConditioner, KiCadSchematicBlock, Block): - """Charging capable a battery reverse protection using PMOS transistors. The highest battery voltage is bounded by the - transistors' Vgs/Vds. There is also a rare case when this circuit being disconnected when a charger is connected first. + """PMOS-based reverse voltage protection, with charging (reverse / bidirectional flow) capability + using additional FETs. + + The highest battery voltage is bounded by the transistors' Vgs/Vds. + There is also a rare case when this circuit being disconnected when a charger is connected first. But always reverse protect. R1 and R2 are the pullup bias resistors for mp1 and mp2 PFet. More info at: https://www.edn.com/reverse-voltage-protection-for-battery-chargers/ """ From 96e3862a610c64ad6e3e3876c8b92628779029db Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Mon, 30 Mar 2026 00:30:29 -0700 Subject: [PATCH 17/21] blacken --- edg/edgir/common_pb2.py | 12 +- edg/edgir/common_pb2.pyi | 205 ++++++---- edg/edgir/elem_pb2.py | 13 +- edg/edgir/elem_pb2.pyi | 619 ++++++++++++++++-------------- edg/edgir/expr_pb2.py | 13 +- edg/edgir/expr_pb2.pyi | 724 ++++++++++++++++++++---------------- edg/edgir/impl_pb2.py | 11 +- edg/edgir/impl_pb2.pyi | 68 ++-- edg/edgir/init_pb2.py | 11 +- edg/edgir/init_pb2.pyi | 124 +++--- edg/edgir/lit_pb2.py | 13 +- edg/edgir/lit_pb2.pyi | 209 ++++++----- edg/edgir/name_pb2.py | 11 +- edg/edgir/name_pb2.pyi | 45 +-- edg/edgir/ref_pb2.py | 11 +- edg/edgir/ref_pb2.pyi | 128 ++++--- edg/edgir/schema_pb2.py | 13 +- edg/edgir/schema_pb2.pyi | 171 +++++---- edg/edgrpc/compiler_pb2.py | 11 +- edg/edgrpc/compiler_pb2.pyi | 113 +++--- edg/edgrpc/hdl_pb2.py | 13 +- edg/edgrpc/hdl_pb2.pyi | 599 ++++++++++++++++------------- 22 files changed, 1760 insertions(+), 1377 deletions(-) diff --git a/edg/edgir/common_pb2.py b/edg/edgir/common_pb2.py index 01c1565e4..a88fe9b8c 100644 --- a/edg/edgir/common_pb2.py +++ b/edg/edgir/common_pb2.py @@ -1,16 +1,20 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12edgir/common.proto\x12\x0cedgir.common"\x95\x03\n\x08Metadata\x12&\n\x07unknown\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12\x0f\n\x05known\x18\x02 \x01(\tH\x00\x121\n\x07members\x18e \x01(\x0b2\x1e.edgir.common.Metadata.MembersH\x01\x12\x13\n\ttext_leaf\x18f \x01(\tH\x01\x12\x12\n\x08bin_leaf\x18g \x01(\x0cH\x01\x125\n\x0esource_locator\x18n \x01(\x0b2\x1b.edgir.common.SourceLocatorH\x01\x12$\n\x05error\x18p \x01(\x0b2\x13.edgir.common.ErrorH\x01\x1a\x86\x01\n\x07Members\x126\n\x04node\x18\n \x03(\x0b2(.edgir.common.Metadata.Members.NodeEntry\x1aC\n\tNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b2\x16.edgir.common.Metadata:\x028\x01B\x06\n\x04typeB\x06\n\x04meta"\xc9\x01\n\rSourceLocator\x12\x14\n\x0cfile_package\x18\x01 \x01(\t\x12\x13\n\x0bline_offset\x18\x02 \x01(\x05\x12\x12\n\ncol_offset\x18\x03 \x01(\x05\x12;\n\x0bsource_type\x18\x04 \x01(\x0e2&.edgir.common.SourceLocator.SourceType"<\n\nSourceType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0e\n\nDEFINITION\x10\x01\x12\x11\n\rINSTANTIATION\x10\x02"X\n\x05Error\x12\x0f\n\x07message\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x03 \x01(\t\x12+\n\x06source\x18\x02 \x03(\x0b2\x1b.edgir.common.SourceLocator"\x07\n\x05Emptyb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x12edgir/common.proto\x12\x0cedgir.common"\x95\x03\n\x08Metadata\x12&\n\x07unknown\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12\x0f\n\x05known\x18\x02 \x01(\tH\x00\x121\n\x07members\x18e \x01(\x0b2\x1e.edgir.common.Metadata.MembersH\x01\x12\x13\n\ttext_leaf\x18f \x01(\tH\x01\x12\x12\n\x08bin_leaf\x18g \x01(\x0cH\x01\x125\n\x0esource_locator\x18n \x01(\x0b2\x1b.edgir.common.SourceLocatorH\x01\x12$\n\x05error\x18p \x01(\x0b2\x13.edgir.common.ErrorH\x01\x1a\x86\x01\n\x07Members\x126\n\x04node\x18\n \x03(\x0b2(.edgir.common.Metadata.Members.NodeEntry\x1aC\n\tNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b2\x16.edgir.common.Metadata:\x028\x01B\x06\n\x04typeB\x06\n\x04meta"\xc9\x01\n\rSourceLocator\x12\x14\n\x0cfile_package\x18\x01 \x01(\t\x12\x13\n\x0bline_offset\x18\x02 \x01(\x05\x12\x12\n\ncol_offset\x18\x03 \x01(\x05\x12;\n\x0bsource_type\x18\x04 \x01(\x0e2&.edgir.common.SourceLocator.SourceType"<\n\nSourceType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0e\n\nDEFINITION\x10\x01\x12\x11\n\rINSTANTIATION\x10\x02"X\n\x05Error\x12\x0f\n\x07message\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x03 \x01(\t\x12+\n\x06source\x18\x02 \x03(\x0b2\x1b.edgir.common.SourceLocator"\x07\n\x05Emptyb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.common_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.common_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _METADATA_MEMBERS_NODEENTRY._options = None - _METADATA_MEMBERS_NODEENTRY._serialized_options = b'8\x01' + _METADATA_MEMBERS_NODEENTRY._serialized_options = b"8\x01" _METADATA._serialized_start = 37 _METADATA._serialized_end = 442 _METADATA_MEMBERS._serialized_start = 292 @@ -24,4 +28,4 @@ _ERROR._serialized_start = 648 _ERROR._serialized_end = 736 _EMPTY._serialized_start = 738 - _EMPTY._serialized_end = 745 \ No newline at end of file + _EMPTY._serialized_end = 745 diff --git a/edg/edgir/common_pb2.pyi b/edg/edgir/common_pb2.pyi index bad85ffc9..4fa8ab79c 100644 --- a/edg/edgir/common_pb2.pyi +++ b/edg/edgir/common_pb2.pyi @@ -7,6 +7,7 @@ Package : edg.common This is where we keep shared types that we reuse and don't have a good place for. """ + from collections import abc as _abc from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message @@ -15,6 +16,7 @@ from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -24,6 +26,7 @@ DESCRIPTOR: _descriptor.FileDescriptor @_typing.final class Metadata(_message.Message): """* Arbitrary metadata stored in tree form.""" + DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -38,31 +41,24 @@ class Metadata(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___Metadata: - ... + def value(self) -> Global___Metadata: ... + def __init__(self, *, key: _builtins.str = ..., value: Global___Metadata | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, key: _builtins.str=..., value: Global___Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... NODE_FIELD_NUMBER: _builtins.int @_builtins.property - def node(self) -> _containers.MessageMap[_builtins.str, Global___Metadata]: - ... + def node(self) -> _containers.MessageMap[_builtins.str, Global___Metadata]: ... + def __init__(self, *, node: _abc.Mapping[_builtins.str, Global___Metadata] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["node", b"node"] - def __init__(self, *, node: _abc.Mapping[_builtins.str, Global___Metadata] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['node', b'node'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... UNKNOWN_FIELD_NUMBER: _builtins.int KNOWN_FIELD_NUMBER: _builtins.int MEMBERS_FIELD_NUMBER: _builtins.int @@ -73,16 +69,12 @@ class Metadata(_message.Message): known: _builtins.str text_leaf: _builtins.str bin_leaf: _builtins.bytes - '* I wanted to split binary and text data, since we might\n just want to dump a raw file/image/datasheet in here\n for safekeeping.\n\n Mixing up binary and textual formats is just a recipe\n for trouble.\n ' + "* I wanted to split binary and text data, since we might\n just want to dump a raw file/image/datasheet in here\n for safekeeping.\n\n Mixing up binary and textual formats is just a recipe\n for trouble.\n " @_builtins.property - def unknown(self) -> Global___Empty: - ... - + def unknown(self) -> Global___Empty: ... @_builtins.property - def members(self) -> Global___Metadata.Members: - ... - + def members(self) -> Global___Metadata.Members: ... @_builtins.property def source_locator(self) -> Global___SourceLocator: """Defined formats @@ -91,31 +83,74 @@ class Metadata(_message.Message): """ @_builtins.property - def error(self) -> Global___Error: - ... - - def __init__(self, *, unknown: Global___Empty | None=..., known: _builtins.str=..., members: Global___Metadata.Members | None=..., text_leaf: _builtins.str=..., bin_leaf: _builtins.bytes=..., source_locator: Global___SourceLocator | None=..., error: Global___Error | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['bin_leaf', b'bin_leaf', 'error', b'error', 'known', b'known', 'members', b'members', 'meta', b'meta', 'source_locator', b'source_locator', 'text_leaf', b'text_leaf', 'type', b'type', 'unknown', b'unknown'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['bin_leaf', b'bin_leaf', 'error', b'error', 'known', b'known', 'members', b'members', 'meta', b'meta', 'source_locator', b'source_locator', 'text_leaf', b'text_leaf', 'type', b'type', 'unknown', b'unknown'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_meta: _TypeAlias = _typing.Literal['members', 'text_leaf', 'bin_leaf', 'source_locator', 'error'] - _WhichOneofArgType_meta: _TypeAlias = _typing.Literal['meta', b'meta'] - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['unknown', 'known'] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] + def error(self) -> Global___Error: ... + def __init__( + self, + *, + unknown: Global___Empty | None = ..., + known: _builtins.str = ..., + members: Global___Metadata.Members | None = ..., + text_leaf: _builtins.str = ..., + bin_leaf: _builtins.bytes = ..., + source_locator: Global___SourceLocator | None = ..., + error: Global___Error | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "bin_leaf", + b"bin_leaf", + "error", + b"error", + "known", + b"known", + "members", + b"members", + "meta", + b"meta", + "source_locator", + b"source_locator", + "text_leaf", + b"text_leaf", + "type", + b"type", + "unknown", + b"unknown", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "bin_leaf", + b"bin_leaf", + "error", + b"error", + "known", + b"known", + "members", + b"members", + "meta", + b"meta", + "source_locator", + b"source_locator", + "text_leaf", + b"text_leaf", + "type", + b"type", + "unknown", + b"unknown", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_meta: _TypeAlias = _typing.Literal[ + "members", "text_leaf", "bin_leaf", "source_locator", "error" + ] + _WhichOneofArgType_meta: _TypeAlias = _typing.Literal["meta", b"meta"] + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["unknown", "known"] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_meta) -> _WhichOneofReturnType_meta | None: - ... - + def WhichOneof(self, oneof_group: _WhichOneofArgType_meta) -> _WhichOneofReturnType_meta | None: ... @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: - ... + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... + Global___Metadata: _TypeAlias = Metadata @_typing.final @@ -124,45 +159,62 @@ class SourceLocator(_message.Message): * For locating source data """ + DESCRIPTOR: _descriptor.Descriptor class _SourceType: - ValueType = _typing.NewType('ValueType', _builtins.int) + ValueType = _typing.NewType("ValueType", _builtins.int) V: _TypeAlias = ValueType - class _SourceTypeEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[SourceLocator._SourceType.ValueType], _builtins.type): + class _SourceTypeEnumTypeWrapper( + _enum_type_wrapper._EnumTypeWrapper[SourceLocator._SourceType.ValueType], _builtins.type + ): DESCRIPTOR: _descriptor.EnumDescriptor UNKNOWN: SourceLocator._SourceType.ValueType DEFINITION: SourceLocator._SourceType.ValueType - 'source defining this class, would be present in library' + "source defining this class, would be present in library" INSTANTIATION: SourceLocator._SourceType.ValueType - 'source of instantiation, would be present in design' + "source of instantiation, would be present in design" - class SourceType(_SourceType, metaclass=_SourceTypeEnumTypeWrapper): - ... + class SourceType(_SourceType, metaclass=_SourceTypeEnumTypeWrapper): ... UNKNOWN: SourceLocator.SourceType.ValueType DEFINITION: SourceLocator.SourceType.ValueType - 'source defining this class, would be present in library' + "source defining this class, would be present in library" INSTANTIATION: SourceLocator.SourceType.ValueType - 'source of instantiation, would be present in design' + "source of instantiation, would be present in design" FILE_PACKAGE_FIELD_NUMBER: _builtins.int LINE_OFFSET_FIELD_NUMBER: _builtins.int COL_OFFSET_FIELD_NUMBER: _builtins.int SOURCE_TYPE_FIELD_NUMBER: _builtins.int file_package: _builtins.str - 'package name (portable, not tied to an absolute path) that locates the file' + "package name (portable, not tied to an absolute path) that locates the file" line_offset: _builtins.int - 'line number' + "line number" col_offset: _builtins.int - 'character offset within the line' + "character offset within the line" source_type: Global___SourceLocator.SourceType.ValueType - def __init__(self, *, file_package: _builtins.str=..., line_offset: _builtins.int=..., col_offset: _builtins.int=..., source_type: Global___SourceLocator.SourceType.ValueType=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['col_offset', b'col_offset', 'file_package', b'file_package', 'line_offset', b'line_offset', 'source_type', b'source_type'] + def __init__( + self, + *, + file_package: _builtins.str = ..., + line_offset: _builtins.int = ..., + col_offset: _builtins.int = ..., + source_type: Global___SourceLocator.SourceType.ValueType = ..., + ) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "col_offset", + b"col_offset", + "file_package", + b"file_package", + "line_offset", + b"line_offset", + "source_type", + b"source_type", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___SourceLocator: _TypeAlias = SourceLocator @_typing.final @@ -170,32 +222,41 @@ class Error(_message.Message): """* Used to communicate results of analysis / checking passes. Limited to Block and Link objects. """ + DESCRIPTOR: _descriptor.Descriptor MESSAGE_FIELD_NUMBER: _builtins.int TRACEBACK_FIELD_NUMBER: _builtins.int SOURCE_FIELD_NUMBER: _builtins.int message: _builtins.str - 'free-form error message' + "free-form error message" traceback: _builtins.str - 'full traceback TODO: should there be a structured stack trace?' + "full traceback TODO: should there be a structured stack trace?" @_builtins.property def source(self) -> _containers.RepeatedCompositeFieldContainer[Global___SourceLocator]: """source locator, eg line of failing constraint""" - def __init__(self, *, message: _builtins.str=..., traceback: _builtins.str=..., source: _abc.Iterable[Global___SourceLocator] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['message', b'message', 'source', b'source', 'traceback', b'traceback'] + def __init__( + self, + *, + message: _builtins.str = ..., + traceback: _builtins.str = ..., + source: _abc.Iterable[Global___SourceLocator] | None = ..., + ) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "message", b"message", "source", b"source", "traceback", b"traceback" + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___Error: _TypeAlias = Error @_typing.final class Empty(_message.Message): """* Placeholder until I figure out how to import properly""" + DESCRIPTOR: _descriptor.Descriptor - def __init__(self) -> None: - ... -Global___Empty: _TypeAlias = Empty \ No newline at end of file + def __init__(self) -> None: ... + +Global___Empty: _TypeAlias = Empty diff --git a/edg/edgir/elem_pb2.py b/edg/edgir/elem_pb2.py index 1848baf86..5b5633fd0 100644 --- a/edg/edgir/elem_pb2.py +++ b/edg/edgir/elem_pb2.py @@ -1,20 +1,25 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import init_pb2 as edgir_dot_init__pb2 from ..edgir import expr_pb2 as edgir_dot_expr__pb2 from ..edgir import ref_pb2 as edgir_dot_ref__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/elem.proto\x12\nedgir.elem\x1a\x12edgir/common.proto\x1a\x10edgir/init.proto\x1a\x10edgir/expr.proto\x1a\x0fedgir/ref.proto"@\n\x0cNamedValInit\x12\x0c\n\x04name\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.init.ValInit"D\n\x0eNamedValueExpr\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"B\n\rNamedPortLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.PortLike"D\n\x0eNamedBlockLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.elem.BlockLike"B\n\rNamedLinkLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.LinkLike"\xbf\x02\n\x04Port\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12/\n\x0bconstraints\x18) \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05ports\x18* \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xca\x01\n\tPortArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x05ports\x18\x0e \x01(\x0b2\x1b.edgir.elem.PortArray.PortsH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a1\n\x05Ports\x12(\n\x05ports\x18( \x03(\x0b2\x19.edgir.elem.NamedPortLikeB\n\n\x08contains"\xb0\x01\n\x08PortLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04port\x18\x03 \x01(\x0b2\x10.edgir.elem.PortH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.PortArrayH\x00B\x04\n\x02is"=\n\tParameter\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04unit\x18\x02 \x01(\t"a\n\x18StringDescriptionElement\x12\x0e\n\x04text\x18\x01 \x01(\tH\x00\x12&\n\x05param\x18\x02 \x01(\x0b2\x15.edgir.elem.ParameterH\x00B\r\n\x0bElementType"\xc4\x06\n\x0eHierarchyBlock\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12E\n\x0eparam_defaults\x18\x0f \x03(\x0b2-.edgir.elem.HierarchyBlock.ParamDefaultsEntry\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\x06blocks\x18* \x03(\x0b2\x1a.edgir.elem.NamedBlockLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18, \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x17 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x14 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12/\n\x0fprerefine_class\x18\x15 \x01(\x0b2\x16.edgir.ref.LibraryPath\x120\n\x10prerefine_mixins\x18\x19 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\tgenerator\x18\x16 \x01(\x0b2\x15.edgir.elem.Generator\x12\x13\n\x0bis_abstract\x18\x1e \x01(\x08\x122\n\x12default_refinement\x18\x1f \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement\x1aK\n\x12ParamDefaultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01":\n\tGenerator\x12-\n\x0frequired_params\x18\x02 \x03(\x0b2\x14.edgir.ref.LocalPath"\\\n\x0cBlockLibrary\x12$\n\x04base\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12&\n\x06mixins\x18\x03 \x03(\x0b2\x16.edgir.ref.LibraryPath"\x9c\x01\n\tBlockLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12,\n\x08lib_elem\x18\x05 \x01(\x0b2\x18.edgir.elem.BlockLibraryH\x00\x12/\n\thierarchy\x18\x04 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00B\x06\n\x04type"\xa4\x03\n\x04Link\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement"\xe2\x01\n\tLinkArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xb2\x01\n\x08LinkLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04link\x18\x03 \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.LinkArrayH\x00B\x06\n\x04typeb\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x10edgir/elem.proto\x12\nedgir.elem\x1a\x12edgir/common.proto\x1a\x10edgir/init.proto\x1a\x10edgir/expr.proto\x1a\x0fedgir/ref.proto"@\n\x0cNamedValInit\x12\x0c\n\x04name\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.init.ValInit"D\n\x0eNamedValueExpr\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"B\n\rNamedPortLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.PortLike"D\n\x0eNamedBlockLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.elem.BlockLike"B\n\rNamedLinkLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.LinkLike"\xbf\x02\n\x04Port\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12/\n\x0bconstraints\x18) \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05ports\x18* \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xca\x01\n\tPortArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x05ports\x18\x0e \x01(\x0b2\x1b.edgir.elem.PortArray.PortsH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a1\n\x05Ports\x12(\n\x05ports\x18( \x03(\x0b2\x19.edgir.elem.NamedPortLikeB\n\n\x08contains"\xb0\x01\n\x08PortLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04port\x18\x03 \x01(\x0b2\x10.edgir.elem.PortH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.PortArrayH\x00B\x04\n\x02is"=\n\tParameter\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04unit\x18\x02 \x01(\t"a\n\x18StringDescriptionElement\x12\x0e\n\x04text\x18\x01 \x01(\tH\x00\x12&\n\x05param\x18\x02 \x01(\x0b2\x15.edgir.elem.ParameterH\x00B\r\n\x0bElementType"\xc4\x06\n\x0eHierarchyBlock\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12E\n\x0eparam_defaults\x18\x0f \x03(\x0b2-.edgir.elem.HierarchyBlock.ParamDefaultsEntry\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\x06blocks\x18* \x03(\x0b2\x1a.edgir.elem.NamedBlockLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18, \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x17 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x14 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12/\n\x0fprerefine_class\x18\x15 \x01(\x0b2\x16.edgir.ref.LibraryPath\x120\n\x10prerefine_mixins\x18\x19 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\tgenerator\x18\x16 \x01(\x0b2\x15.edgir.elem.Generator\x12\x13\n\x0bis_abstract\x18\x1e \x01(\x08\x122\n\x12default_refinement\x18\x1f \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement\x1aK\n\x12ParamDefaultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01":\n\tGenerator\x12-\n\x0frequired_params\x18\x02 \x03(\x0b2\x14.edgir.ref.LocalPath"\\\n\x0cBlockLibrary\x12$\n\x04base\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12&\n\x06mixins\x18\x03 \x03(\x0b2\x16.edgir.ref.LibraryPath"\x9c\x01\n\tBlockLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12,\n\x08lib_elem\x18\x05 \x01(\x0b2\x18.edgir.elem.BlockLibraryH\x00\x12/\n\thierarchy\x18\x04 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00B\x06\n\x04type"\xa4\x03\n\x04Link\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement"\xe2\x01\n\tLinkArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xb2\x01\n\x08LinkLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04link\x18\x03 \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.LinkArrayH\x00B\x06\n\x04typeb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.elem_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.elem_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _HIERARCHYBLOCK_PARAMDEFAULTSENTRY._options = None - _HIERARCHYBLOCK_PARAMDEFAULTSENTRY._serialized_options = b'8\x01' + _HIERARCHYBLOCK_PARAMDEFAULTSENTRY._serialized_options = b"8\x01" _NAMEDVALINIT._serialized_start = 105 _NAMEDVALINIT._serialized_end = 169 _NAMEDVALUEEXPR._serialized_start = 171 @@ -52,4 +57,4 @@ _LINKARRAY._serialized_start = 2891 _LINKARRAY._serialized_end = 3117 _LINKLIKE._serialized_start = 3120 - _LINKLIKE._serialized_end = 3298 \ No newline at end of file + _LINKLIKE._serialized_end = 3298 diff --git a/edg/edgir/elem_pb2.pyi b/edg/edgir/elem_pb2.pyi index 9c09803fc..4922395ee 100644 --- a/edg/edgir/elem_pb2.pyi +++ b/edg/edgir/elem_pb2.pyi @@ -13,6 +13,7 @@ We don't strictly differentiate between library elements and elements within a design within the protobuf. In general, when there is a library element, we """ + from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import expr_pb2 as _expr_pb2 @@ -24,6 +25,7 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -36,25 +38,22 @@ class NamedValInit(_message.Message): are unordered (whereas we want to preserve ordering to preserve design intent through the compiler), we use a sequence of these pairs. """ + DESCRIPTOR: _descriptor.Descriptor NAME_FIELD_NUMBER: _builtins.int VALUE_FIELD_NUMBER: _builtins.int name: _builtins.str @_builtins.property - def value(self) -> _init_pb2.ValInit: - ... + def value(self) -> _init_pb2.ValInit: ... + def __init__(self, *, name: _builtins.str = ..., value: _init_pb2.ValInit | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, name: _builtins.str=..., value: _init_pb2.ValInit | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___NamedValInit: _TypeAlias = NamedValInit @_typing.final @@ -65,19 +64,15 @@ class NamedValueExpr(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> _expr_pb2.ValueExpr: - ... + def value(self) -> _expr_pb2.ValueExpr: ... + def __init__(self, *, name: _builtins.str = ..., value: _expr_pb2.ValueExpr | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, name: _builtins.str=..., value: _expr_pb2.ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___NamedValueExpr: _TypeAlias = NamedValueExpr @_typing.final @@ -88,19 +83,15 @@ class NamedPortLike(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> Global___PortLike: - ... + def value(self) -> Global___PortLike: ... + def __init__(self, *, name: _builtins.str = ..., value: Global___PortLike | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, name: _builtins.str=..., value: Global___PortLike | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___NamedPortLike: _TypeAlias = NamedPortLike @_typing.final @@ -111,19 +102,15 @@ class NamedBlockLike(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> Global___BlockLike: - ... + def value(self) -> Global___BlockLike: ... + def __init__(self, *, name: _builtins.str = ..., value: Global___BlockLike | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, name: _builtins.str=..., value: Global___BlockLike | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___NamedBlockLike: _TypeAlias = NamedBlockLike @_typing.final @@ -134,19 +121,15 @@ class NamedLinkLike(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> Global___LinkLike: - ... + def value(self) -> Global___LinkLike: ... + def __init__(self, *, name: _builtins.str = ..., value: Global___LinkLike | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, name: _builtins.str=..., value: Global___LinkLike | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___NamedLinkLike: _TypeAlias = NamedLinkLike @_typing.final @@ -161,21 +144,13 @@ class Port(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: - ... - + def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: ... @_builtins.property - def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: - ... - + def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: ... @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: - ... - + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... @_builtins.property - def self_class(self) -> _ref_pb2.LibraryPath: - ... - + def self_class(self) -> _ref_pb2.LibraryPath: ... @_builtins.property def superclasses(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: """superclasses, may be empty""" @@ -188,16 +163,39 @@ class Port(_message.Message): def meta(self) -> _common_pb2.Metadata: """TODO: this provides type hierarchy data only, inheritance semantics are currently undefined""" - def __init__(self, *, params: _abc.Iterable[Global___NamedValInit] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., self_class: _ref_pb2.LibraryPath | None=..., superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'self_class', b'self_class'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['constraints', b'constraints', 'meta', b'meta', 'params', b'params', 'ports', b'ports', 'self_class', b'self_class', 'super_superclasses', b'super_superclasses', 'superclasses', b'superclasses'] + def __init__( + self, + *, + params: _abc.Iterable[Global___NamedValInit] | None = ..., + constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., + ports: _abc.Iterable[Global___NamedPortLike] | None = ..., + self_class: _ref_pb2.LibraryPath | None = ..., + superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., + super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "self_class", b"self_class"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "constraints", + b"constraints", + "meta", + b"meta", + "params", + b"params", + "ports", + b"ports", + "self_class", + b"self_class", + "super_superclasses", + b"super_superclasses", + "superclasses", + b"superclasses", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___Port: _TypeAlias = Port @_typing.final @@ -210,15 +208,12 @@ class PortArray(_message.Message): PORTS_FIELD_NUMBER: _builtins.int @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: - ... + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... + def __init__(self, *, ports: _abc.Iterable[Global___NamedPortLike] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["ports", b"ports"] - def __init__(self, *, ports: _abc.Iterable[Global___NamedPortLike] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['ports', b'ports'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... SELF_CLASS_FIELD_NUMBER: _builtins.int PORTS_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @@ -230,33 +225,37 @@ class PortArray(_message.Message): """ @_builtins.property - def ports(self) -> Global___PortArray.Ports: - ... - + def ports(self) -> Global___PortArray.Ports: ... @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + self_class: _ref_pb2.LibraryPath | None = ..., + ports: Global___PortArray.Ports | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "contains", b"contains", "meta", b"meta", "ports", b"ports", "self_class", b"self_class" + ] - def __init__(self, *, self_class: _ref_pb2.LibraryPath | None=..., ports: Global___PortArray.Ports | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['contains', b'contains', 'meta', b'meta', 'ports', b'ports', 'self_class', b'self_class'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "contains", b"contains", "meta", b"meta", "ports", b"ports", "self_class", b"self_class" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['contains', b'contains', 'meta', b'meta', 'ports', b'ports', 'self_class', b'self_class'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_contains: _TypeAlias = _typing.Literal["ports"] + _WhichOneofArgType_contains: _TypeAlias = _typing.Literal["contains", b"contains"] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_contains: _TypeAlias = _typing.Literal['ports'] - _WhichOneofArgType_contains: _TypeAlias = _typing.Literal['contains', b'contains'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_contains) -> _WhichOneofReturnType_contains | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_contains) -> _WhichOneofReturnType_contains | None: - ... Global___PortArray: _TypeAlias = PortArray @_typing.final class PortLike(_message.Message): """* Wrapper for different port like elements""" + DESCRIPTOR: _descriptor.Descriptor UNDEFINED_FIELD_NUMBER: _builtins.int LIB_ELEM_FIELD_NUMBER: _builtins.int @@ -264,36 +263,38 @@ class PortLike(_message.Message): ARRAY_FIELD_NUMBER: _builtins.int @_builtins.property - def undefined(self) -> _common_pb2.Empty: - ... - + def undefined(self) -> _common_pb2.Empty: ... @_builtins.property - def lib_elem(self) -> _ref_pb2.LibraryPath: - ... - + def lib_elem(self) -> _ref_pb2.LibraryPath: ... @_builtins.property def port(self) -> Global___Port: """* 'port' disallowed w/in the library""" @_builtins.property - def array(self) -> Global___PortArray: - ... + def array(self) -> Global___PortArray: ... + def __init__( + self, + *, + undefined: _common_pb2.Empty | None = ..., + lib_elem: _ref_pb2.LibraryPath | None = ..., + port: Global___Port | None = ..., + array: Global___PortArray | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "array", b"array", "is", b"is", "lib_elem", b"lib_elem", "port", b"port", "undefined", b"undefined" + ] - def __init__(self, *, undefined: _common_pb2.Empty | None=..., lib_elem: _ref_pb2.LibraryPath | None=..., port: Global___Port | None=..., array: Global___PortArray | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'is', b'is', 'lib_elem', b'lib_elem', 'port', b'port', 'undefined', b'undefined'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "array", b"array", "is", b"is", "lib_elem", b"lib_elem", "port", b"port", "undefined", b"undefined" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'is', b'is', 'lib_elem', b'lib_elem', 'port', b'port', 'undefined', b'undefined'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_is: _TypeAlias = _typing.Literal["undefined", "lib_elem", "port", "array"] + _WhichOneofArgType_is: _TypeAlias = _typing.Literal["is", b"is"] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_is: _TypeAlias = _typing.Literal['undefined', 'lib_elem', 'port', 'array'] - _WhichOneofArgType_is: _TypeAlias = _typing.Literal['is', b'is'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_is) -> _WhichOneofReturnType_is | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_is) -> _WhichOneofReturnType_is | None: - ... Global___PortLike: _TypeAlias = PortLike @_typing.final @@ -304,19 +305,15 @@ class Parameter(_message.Message): unit: _builtins.str @_builtins.property - def path(self) -> _ref_pb2.LocalPath: - ... + def path(self) -> _ref_pb2.LocalPath: ... + def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., unit: _builtins.str = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path"] - def __init__(self, *, path: _ref_pb2.LocalPath | None=..., unit: _builtins.str=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "unit", b"unit"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'unit', b'unit'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___Parameter: _TypeAlias = Parameter @_typing.final @@ -327,24 +324,19 @@ class StringDescriptionElement(_message.Message): text: _builtins.str @_builtins.property - def param(self) -> Global___Parameter: - ... + def param(self) -> Global___Parameter: ... + def __init__(self, *, text: _builtins.str = ..., param: Global___Parameter | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["ElementType", b"ElementType", "param", b"param", "text", b"text"] - def __init__(self, *, text: _builtins.str=..., param: Global___Parameter | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['ElementType', b'ElementType', 'param', b'param', 'text', b'text'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["ElementType", b"ElementType", "param", b"param", "text", b"text"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['ElementType', b'ElementType', 'param', b'param', 'text', b'text'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_ElementType: _TypeAlias = _typing.Literal["text", "param"] + _WhichOneofArgType_ElementType: _TypeAlias = _typing.Literal["ElementType", b"ElementType"] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_ElementType: _TypeAlias = _typing.Literal['text', 'param'] - _WhichOneofArgType_ElementType: _TypeAlias = _typing.Literal['ElementType', b'ElementType'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_ElementType) -> _WhichOneofReturnType_ElementType | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_ElementType) -> _WhichOneofReturnType_ElementType | None: - ... Global___StringDescriptionElement: _TypeAlias = StringDescriptionElement @_typing.final @@ -359,19 +351,15 @@ class HierarchyBlock(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> _expr_pb2.ValueExpr: - ... + def value(self) -> _expr_pb2.ValueExpr: ... + def __init__(self, *, key: _builtins.str = ..., value: _expr_pb2.ValueExpr | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, key: _builtins.str=..., value: _expr_pb2.ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... PARAMS_FIELD_NUMBER: _builtins.int PARAM_DEFAULTS_FIELD_NUMBER: _builtins.int PORTS_FIELD_NUMBER: _builtins.int @@ -389,12 +377,10 @@ class HierarchyBlock(_message.Message): META_FIELD_NUMBER: _builtins.int DESCRIPTION_FIELD_NUMBER: _builtins.int is_abstract: _builtins.bool - 'true if self_class is abstract, and should error if used in a design' + "true if self_class is abstract, and should error if used in a design" @_builtins.property - def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: - ... - + def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: ... @_builtins.property def param_defaults(self) -> _containers.MessageMap[_builtins.str, _expr_pb2.ValueExpr]: """Refinements may introduce new parameters which would not be assigned a value in the parent class. @@ -403,9 +389,7 @@ class HierarchyBlock(_message.Message): """ @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: - ... - + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... @_builtins.property def blocks(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedBlockLike]: """* Bridges, which adapt an edge port to a link port - eg, edge VoltageSink to an internal link @@ -414,9 +398,7 @@ class HierarchyBlock(_message.Message): """ @_builtins.property - def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: - ... - + def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: ... @_builtins.property def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: """* Connections between internal block and link ports are represented by connected constraints. @@ -452,23 +434,80 @@ class HierarchyBlock(_message.Message): """optional default refinement subclass, only valid for library blocks""" @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... - - @_builtins.property - def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: - ... - - def __init__(self, *, params: _abc.Iterable[Global___NamedValInit] | None=..., param_defaults: _abc.Mapping[_builtins.str, _expr_pb2.ValueExpr] | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., blocks: _abc.Iterable[Global___NamedBlockLike] | None=..., links: _abc.Iterable[Global___NamedLinkLike] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., self_class: _ref_pb2.LibraryPath | None=..., superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., prerefine_class: _ref_pb2.LibraryPath | None=..., prerefine_mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., generator: Global___Generator | None=..., is_abstract: _builtins.bool=..., default_refinement: _ref_pb2.LibraryPath | None=..., meta: _common_pb2.Metadata | None=..., description: _abc.Iterable[Global___StringDescriptionElement] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['default_refinement', b'default_refinement', 'generator', b'generator', 'meta', b'meta', 'prerefine_class', b'prerefine_class', 'self_class', b'self_class'] + def meta(self) -> _common_pb2.Metadata: ... + @_builtins.property + def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: ... + def __init__( + self, + *, + params: _abc.Iterable[Global___NamedValInit] | None = ..., + param_defaults: _abc.Mapping[_builtins.str, _expr_pb2.ValueExpr] | None = ..., + ports: _abc.Iterable[Global___NamedPortLike] | None = ..., + blocks: _abc.Iterable[Global___NamedBlockLike] | None = ..., + links: _abc.Iterable[Global___NamedLinkLike] | None = ..., + constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., + self_class: _ref_pb2.LibraryPath | None = ..., + superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., + super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., + prerefine_class: _ref_pb2.LibraryPath | None = ..., + prerefine_mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., + generator: Global___Generator | None = ..., + is_abstract: _builtins.bool = ..., + default_refinement: _ref_pb2.LibraryPath | None = ..., + meta: _common_pb2.Metadata | None = ..., + description: _abc.Iterable[Global___StringDescriptionElement] | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "default_refinement", + b"default_refinement", + "generator", + b"generator", + "meta", + b"meta", + "prerefine_class", + b"prerefine_class", + "self_class", + b"self_class", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "blocks", + b"blocks", + "constraints", + b"constraints", + "default_refinement", + b"default_refinement", + "description", + b"description", + "generator", + b"generator", + "is_abstract", + b"is_abstract", + "links", + b"links", + "meta", + b"meta", + "param_defaults", + b"param_defaults", + "params", + b"params", + "ports", + b"ports", + "prerefine_class", + b"prerefine_class", + "prerefine_mixins", + b"prerefine_mixins", + "self_class", + b"self_class", + "super_superclasses", + b"super_superclasses", + "superclasses", + b"superclasses", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['blocks', b'blocks', 'constraints', b'constraints', 'default_refinement', b'default_refinement', 'description', b'description', 'generator', b'generator', 'is_abstract', b'is_abstract', 'links', b'links', 'meta', b'meta', 'param_defaults', b'param_defaults', 'params', b'params', 'ports', b'ports', 'prerefine_class', b'prerefine_class', 'prerefine_mixins', b'prerefine_mixins', 'self_class', b'self_class', 'super_superclasses', b'super_superclasses', 'superclasses', b'superclasses'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___HierarchyBlock: _TypeAlias = HierarchyBlock @_typing.final @@ -482,12 +521,11 @@ class Generator(_message.Message): These parameters are the only ones accessible to the generator. """ - def __init__(self, *, required_params: _abc.Iterable[_ref_pb2.LocalPath] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['required_params', b'required_params'] + def __init__(self, *, required_params: _abc.Iterable[_ref_pb2.LocalPath] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["required_params", b"required_params"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___Generator: _TypeAlias = Generator @_typing.final @@ -497,23 +535,19 @@ class BlockLibrary(_message.Message): MIXINS_FIELD_NUMBER: _builtins.int @_builtins.property - def base(self) -> _ref_pb2.LibraryPath: - ... - + def base(self) -> _ref_pb2.LibraryPath: ... @_builtins.property - def mixins(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: - ... + def mixins(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: ... + def __init__( + self, *, base: _ref_pb2.LibraryPath | None = ..., mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["base", b"base"] - def __init__(self, *, base: _ref_pb2.LibraryPath | None=..., mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['base', b'base'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["base", b"base", "mixins", b"mixins"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['base', b'base', 'mixins', b'mixins'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___BlockLibrary: _TypeAlias = BlockLibrary @_typing.final @@ -524,32 +558,35 @@ class BlockLike(_message.Message): HIERARCHY_FIELD_NUMBER: _builtins.int @_builtins.property - def undefined(self) -> _common_pb2.Empty: - ... - + def undefined(self) -> _common_pb2.Empty: ... @_builtins.property - def lib_elem(self) -> Global___BlockLibrary: - ... - + def lib_elem(self) -> Global___BlockLibrary: ... @_builtins.property def hierarchy(self) -> Global___HierarchyBlock: """* not allowed w/in the library""" - def __init__(self, *, undefined: _common_pb2.Empty | None=..., lib_elem: Global___BlockLibrary | None=..., hierarchy: Global___HierarchyBlock | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['hierarchy', b'hierarchy', 'lib_elem', b'lib_elem', 'type', b'type', 'undefined', b'undefined'] + def __init__( + self, + *, + undefined: _common_pb2.Empty | None = ..., + lib_elem: Global___BlockLibrary | None = ..., + hierarchy: Global___HierarchyBlock | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "hierarchy", b"hierarchy", "lib_elem", b"lib_elem", "type", b"type", "undefined", b"undefined" + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "hierarchy", b"hierarchy", "lib_elem", b"lib_elem", "type", b"type", "undefined", b"undefined" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['hierarchy', b'hierarchy', 'lib_elem', b'lib_elem', 'type', b'type', 'undefined', b'undefined'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["undefined", "lib_elem", "hierarchy"] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['undefined', 'lib_elem', 'hierarchy'] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: - ... Global___BlockLike: _TypeAlias = BlockLike @_typing.final @@ -566,25 +603,15 @@ class Link(_message.Message): DESCRIPTION_FIELD_NUMBER: _builtins.int @_builtins.property - def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: - ... - + def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: ... @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: - ... - + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... @_builtins.property - def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: - ... - + def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: ... @_builtins.property - def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: - ... - + def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: ... @_builtins.property - def self_class(self) -> _ref_pb2.LibraryPath: - ... - + def self_class(self) -> _ref_pb2.LibraryPath: ... @_builtins.property def superclasses(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: """superclasses, may be empty""" @@ -598,19 +625,46 @@ class Link(_message.Message): """TODO: this provides type hierarchy data only, inheritance semantics are currently undefined""" @_builtins.property - def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: - ... - - def __init__(self, *, params: _abc.Iterable[Global___NamedValInit] | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., links: _abc.Iterable[Global___NamedLinkLike] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., self_class: _ref_pb2.LibraryPath | None=..., superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., meta: _common_pb2.Metadata | None=..., description: _abc.Iterable[Global___StringDescriptionElement] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'self_class', b'self_class'] + def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: ... + def __init__( + self, + *, + params: _abc.Iterable[Global___NamedValInit] | None = ..., + ports: _abc.Iterable[Global___NamedPortLike] | None = ..., + links: _abc.Iterable[Global___NamedLinkLike] | None = ..., + constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., + self_class: _ref_pb2.LibraryPath | None = ..., + superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., + super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., + meta: _common_pb2.Metadata | None = ..., + description: _abc.Iterable[Global___StringDescriptionElement] | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "self_class", b"self_class"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "constraints", + b"constraints", + "description", + b"description", + "links", + b"links", + "meta", + b"meta", + "params", + b"params", + "ports", + b"ports", + "self_class", + b"self_class", + "super_superclasses", + b"super_superclasses", + "superclasses", + b"superclasses", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['constraints', b'constraints', 'description', b'description', 'links', b'links', 'meta', b'meta', 'params', b'params', 'ports', b'ports', 'self_class', b'self_class', 'super_superclasses', b'super_superclasses', 'superclasses', b'superclasses'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___Link: _TypeAlias = Link @_typing.final @@ -639,23 +693,36 @@ class LinkArray(_message.Message): """includes all exported constraints to map link ports to my ports""" @_builtins.property - def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: - ... + def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: ... + @_builtins.property + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + self_class: _ref_pb2.LibraryPath | None = ..., + ports: _abc.Iterable[Global___NamedPortLike] | None = ..., + constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., + links: _abc.Iterable[Global___NamedLinkLike] | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "self_class", b"self_class"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "constraints", + b"constraints", + "links", + b"links", + "meta", + b"meta", + "ports", + b"ports", + "self_class", + b"self_class", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... - - def __init__(self, *, self_class: _ref_pb2.LibraryPath | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., links: _abc.Iterable[Global___NamedLinkLike] | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'self_class', b'self_class'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['constraints', b'constraints', 'links', b'links', 'meta', b'meta', 'ports', b'ports', 'self_class', b'self_class'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___LinkArray: _TypeAlias = LinkArray @_typing.final @@ -667,34 +734,36 @@ class LinkLike(_message.Message): ARRAY_FIELD_NUMBER: _builtins.int @_builtins.property - def undefined(self) -> _common_pb2.Empty: - ... - + def undefined(self) -> _common_pb2.Empty: ... @_builtins.property - def lib_elem(self) -> _ref_pb2.LibraryPath: - ... - + def lib_elem(self) -> _ref_pb2.LibraryPath: ... @_builtins.property def link(self) -> Global___Link: """* not allowed w/in the library""" @_builtins.property - def array(self) -> Global___LinkArray: - ... + def array(self) -> Global___LinkArray: ... + def __init__( + self, + *, + undefined: _common_pb2.Empty | None = ..., + lib_elem: _ref_pb2.LibraryPath | None = ..., + link: Global___Link | None = ..., + array: Global___LinkArray | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "array", b"array", "lib_elem", b"lib_elem", "link", b"link", "type", b"type", "undefined", b"undefined" + ] - def __init__(self, *, undefined: _common_pb2.Empty | None=..., lib_elem: _ref_pb2.LibraryPath | None=..., link: Global___Link | None=..., array: Global___LinkArray | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'lib_elem', b'lib_elem', 'link', b'link', 'type', b'type', 'undefined', b'undefined'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "array", b"array", "lib_elem", b"lib_elem", "link", b"link", "type", b"type", "undefined", b"undefined" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'lib_elem', b'lib_elem', 'link', b'link', 'type', b'type', 'undefined', b'undefined'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["undefined", "lib_elem", "link", "array"] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['undefined', 'lib_elem', 'link', 'array'] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: - ... -Global___LinkLike: _TypeAlias = LinkLike \ No newline at end of file +Global___LinkLike: _TypeAlias = LinkLike diff --git a/edg/edgir/expr_pb2.py b/edg/edgir/expr_pb2.py index db1910d84..9bc92c74b 100644 --- a/edg/edgir/expr_pb2.py +++ b/edg/edgir/expr_pb2.py @@ -1,19 +1,24 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import ref_pb2 as edgir_dot_ref__pb2 from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import lit_pb2 as edgir_dot_lit__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/expr.proto\x12\nedgir.expr\x1a\x0fedgir/ref.proto\x1a\x12edgir/common.proto\x1a\x0fedgir/lit.proto"\xb4\x01\n\tUnaryExpr\x12$\n\x02op\x18\x01 \x01(\x0e2\x18.edgir.expr.UnaryExpr.Op\x12"\n\x03val\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"]\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\n\n\x06NEGATE\x10\x01\x12\x07\n\x03NOT\x10\x02\x12\n\n\x06INVERT\x10\x03\x12\x07\n\x03MIN\x10\x04\x12\x07\n\x03MAX\x10\x05\x12\n\n\x06CENTER\x10\x06\x12\t\n\x05WIDTH\x10\x07"\x9f\x02\n\x0cUnarySetExpr\x12\'\n\x02op\x18\x01 \x01(\x0e2\x1b.edgir.expr.UnarySetExpr.Op\x12#\n\x04vals\x18\x04 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xc0\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03SUM\x10\x01\x12\x0c\n\x08ALL_TRUE\x10\x02\x12\x0c\n\x08ANY_TRUE\x10\x03\x12\n\n\x06ALL_EQ\x10\x04\x12\x0e\n\nALL_UNIQUE\x10\x05\x12\x0b\n\x07MAXIMUM\x10\n\x12\x0b\n\x07MINIMUM\x10\x0b\x12\x0f\n\x0bSET_EXTRACT\x10\x0c\x12\x10\n\x0cINTERSECTION\x10\r\x12\x08\n\x04HULL\x10\x0e\x12\n\n\x06NEGATE\x10\x14\x12\n\n\x06INVERT\x10\x15\x12\x0b\n\x07FLATTEN\x10\x1e"\xd4\x02\n\nBinaryExpr\x12%\n\x02op\x18\x01 \x01(\x0e2\x19.edgir.expr.BinaryExpr.Op\x12"\n\x03lhs\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xd6\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\x0f\n\x0bSHRINK_MULT\x107\x12\x07\n\x03AND\x10\x14\x12\x06\n\x02OR\x10\x15\x12\x07\n\x03XOR\x10\x16\x12\x0b\n\x07IMPLIES\x10\x17\x12\x06\n\x02EQ\x10\x1e\x12\x07\n\x03NEQ\x10\x1f\x12\x06\n\x02GT\x10(\x12\x07\n\x03GTE\x10)\x12\x06\n\x02LT\x10*\x12\x07\n\x03LTE\x10,\x12\x07\n\x03MAX\x10-\x12\x07\n\x03MIN\x10.\x12\x10\n\x0cINTERSECTION\x103\x12\x08\n\x04HULL\x106\x12\n\n\x06WITHIN\x105\x12\t\n\x05RANGE\x10\x01"\xbf\x01\n\rBinarySetExpr\x12(\n\x02op\x18\x01 \x01(\x0e2\x1c.edgir.expr.BinarySetExpr.Op\x12$\n\x05lhset\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr":\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\n\n\x06CONCAT\x10\x14\x12\x06\n\x02EQ\x10\x1e"0\n\tArrayExpr\x12#\n\x04vals\x18\x01 \x03(\x0b2\x15.edgir.expr.ValueExpr"[\n\tRangeExpr\x12&\n\x07minimum\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12&\n\x07maximum\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x80\x01\n\nStructExpr\x12.\n\x04vals\x18\x01 \x03(\x0b2 .edgir.expr.StructExpr.ValsEntry\x1aB\n\tValsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01"\xa3\x01\n\x0eIfThenElseExpr\x12#\n\x04cond\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03tru\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03fal\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"]\n\x0bExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x05index\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"^\n\x0eMapExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x04path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPath"\x91\x01\n\rConnectedExpr\x12)\n\nblock_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12(\n\tlink_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12+\n\x08expanded\x18\x03 \x03(\x0b2\x19.edgir.expr.ConnectedExpr"\x9c\x01\n\x0cExportedExpr\x12,\n\rexterior_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x122\n\x13internal_block_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12*\n\x08expanded\x18\x03 \x03(\x0b2\x18.edgir.expr.ExportedExpr"S\n\nAssignExpr\x12!\n\x03dst\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x03src\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x97\x07\n\tValueExpr\x12&\n\x07literal\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLitH\x00\x12(\n\x06binary\x18\x02 \x01(\x0b2\x16.edgir.expr.BinaryExprH\x00\x12/\n\nbinary_set\x18\x12 \x01(\x0b2\x19.edgir.expr.BinarySetExprH\x00\x12&\n\x05unary\x18\x03 \x01(\x0b2\x15.edgir.expr.UnaryExprH\x00\x12-\n\tunary_set\x18\x04 \x01(\x0b2\x18.edgir.expr.UnarySetExprH\x00\x12&\n\x05array\x18\x06 \x01(\x0b2\x15.edgir.expr.ArrayExprH\x00\x12(\n\x06struct\x18\x07 \x01(\x0b2\x16.edgir.expr.StructExprH\x00\x12&\n\x05range\x18\x08 \x01(\x0b2\x15.edgir.expr.RangeExprH\x00\x120\n\nifThenElse\x18\n \x01(\x0b2\x1a.edgir.expr.IfThenElseExprH\x00\x12*\n\x07extract\x18\x0c \x01(\x0b2\x17.edgir.expr.ExtractExprH\x00\x121\n\x0bmap_extract\x18\x0e \x01(\x0b2\x1a.edgir.expr.MapExtractExprH\x00\x12.\n\tconnected\x18\x0f \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x12,\n\x08exported\x18\x10 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x123\n\x0econnectedArray\x18\x13 \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x121\n\rexportedArray\x18\x14 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12(\n\x06assign\x18\x11 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x122\n\x0eexportedTunnel\x18\x15 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12.\n\x0cassignTunnel\x18\x16 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x12#\n\x03ref\x18c \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04exprb\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x10edgir/expr.proto\x12\nedgir.expr\x1a\x0fedgir/ref.proto\x1a\x12edgir/common.proto\x1a\x0fedgir/lit.proto"\xb4\x01\n\tUnaryExpr\x12$\n\x02op\x18\x01 \x01(\x0e2\x18.edgir.expr.UnaryExpr.Op\x12"\n\x03val\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"]\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\n\n\x06NEGATE\x10\x01\x12\x07\n\x03NOT\x10\x02\x12\n\n\x06INVERT\x10\x03\x12\x07\n\x03MIN\x10\x04\x12\x07\n\x03MAX\x10\x05\x12\n\n\x06CENTER\x10\x06\x12\t\n\x05WIDTH\x10\x07"\x9f\x02\n\x0cUnarySetExpr\x12\'\n\x02op\x18\x01 \x01(\x0e2\x1b.edgir.expr.UnarySetExpr.Op\x12#\n\x04vals\x18\x04 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xc0\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03SUM\x10\x01\x12\x0c\n\x08ALL_TRUE\x10\x02\x12\x0c\n\x08ANY_TRUE\x10\x03\x12\n\n\x06ALL_EQ\x10\x04\x12\x0e\n\nALL_UNIQUE\x10\x05\x12\x0b\n\x07MAXIMUM\x10\n\x12\x0b\n\x07MINIMUM\x10\x0b\x12\x0f\n\x0bSET_EXTRACT\x10\x0c\x12\x10\n\x0cINTERSECTION\x10\r\x12\x08\n\x04HULL\x10\x0e\x12\n\n\x06NEGATE\x10\x14\x12\n\n\x06INVERT\x10\x15\x12\x0b\n\x07FLATTEN\x10\x1e"\xd4\x02\n\nBinaryExpr\x12%\n\x02op\x18\x01 \x01(\x0e2\x19.edgir.expr.BinaryExpr.Op\x12"\n\x03lhs\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xd6\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\x0f\n\x0bSHRINK_MULT\x107\x12\x07\n\x03AND\x10\x14\x12\x06\n\x02OR\x10\x15\x12\x07\n\x03XOR\x10\x16\x12\x0b\n\x07IMPLIES\x10\x17\x12\x06\n\x02EQ\x10\x1e\x12\x07\n\x03NEQ\x10\x1f\x12\x06\n\x02GT\x10(\x12\x07\n\x03GTE\x10)\x12\x06\n\x02LT\x10*\x12\x07\n\x03LTE\x10,\x12\x07\n\x03MAX\x10-\x12\x07\n\x03MIN\x10.\x12\x10\n\x0cINTERSECTION\x103\x12\x08\n\x04HULL\x106\x12\n\n\x06WITHIN\x105\x12\t\n\x05RANGE\x10\x01"\xbf\x01\n\rBinarySetExpr\x12(\n\x02op\x18\x01 \x01(\x0e2\x1c.edgir.expr.BinarySetExpr.Op\x12$\n\x05lhset\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr":\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\n\n\x06CONCAT\x10\x14\x12\x06\n\x02EQ\x10\x1e"0\n\tArrayExpr\x12#\n\x04vals\x18\x01 \x03(\x0b2\x15.edgir.expr.ValueExpr"[\n\tRangeExpr\x12&\n\x07minimum\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12&\n\x07maximum\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x80\x01\n\nStructExpr\x12.\n\x04vals\x18\x01 \x03(\x0b2 .edgir.expr.StructExpr.ValsEntry\x1aB\n\tValsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01"\xa3\x01\n\x0eIfThenElseExpr\x12#\n\x04cond\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03tru\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03fal\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"]\n\x0bExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x05index\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"^\n\x0eMapExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x04path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPath"\x91\x01\n\rConnectedExpr\x12)\n\nblock_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12(\n\tlink_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12+\n\x08expanded\x18\x03 \x03(\x0b2\x19.edgir.expr.ConnectedExpr"\x9c\x01\n\x0cExportedExpr\x12,\n\rexterior_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x122\n\x13internal_block_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12*\n\x08expanded\x18\x03 \x03(\x0b2\x18.edgir.expr.ExportedExpr"S\n\nAssignExpr\x12!\n\x03dst\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x03src\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x97\x07\n\tValueExpr\x12&\n\x07literal\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLitH\x00\x12(\n\x06binary\x18\x02 \x01(\x0b2\x16.edgir.expr.BinaryExprH\x00\x12/\n\nbinary_set\x18\x12 \x01(\x0b2\x19.edgir.expr.BinarySetExprH\x00\x12&\n\x05unary\x18\x03 \x01(\x0b2\x15.edgir.expr.UnaryExprH\x00\x12-\n\tunary_set\x18\x04 \x01(\x0b2\x18.edgir.expr.UnarySetExprH\x00\x12&\n\x05array\x18\x06 \x01(\x0b2\x15.edgir.expr.ArrayExprH\x00\x12(\n\x06struct\x18\x07 \x01(\x0b2\x16.edgir.expr.StructExprH\x00\x12&\n\x05range\x18\x08 \x01(\x0b2\x15.edgir.expr.RangeExprH\x00\x120\n\nifThenElse\x18\n \x01(\x0b2\x1a.edgir.expr.IfThenElseExprH\x00\x12*\n\x07extract\x18\x0c \x01(\x0b2\x17.edgir.expr.ExtractExprH\x00\x121\n\x0bmap_extract\x18\x0e \x01(\x0b2\x1a.edgir.expr.MapExtractExprH\x00\x12.\n\tconnected\x18\x0f \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x12,\n\x08exported\x18\x10 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x123\n\x0econnectedArray\x18\x13 \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x121\n\rexportedArray\x18\x14 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12(\n\x06assign\x18\x11 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x122\n\x0eexportedTunnel\x18\x15 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12.\n\x0cassignTunnel\x18\x16 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x12#\n\x03ref\x18c \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04exprb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.expr_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.expr_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _STRUCTEXPR_VALSENTRY._options = None - _STRUCTEXPR_VALSENTRY._serialized_options = b'8\x01' + _STRUCTEXPR_VALSENTRY._serialized_options = b"8\x01" _UNARYEXPR._serialized_start = 87 _UNARYEXPR._serialized_end = 267 _UNARYEXPR_OP._serialized_start = 174 @@ -51,4 +56,4 @@ _ASSIGNEXPR._serialized_start = 2034 _ASSIGNEXPR._serialized_end = 2117 _VALUEEXPR._serialized_start = 2120 - _VALUEEXPR._serialized_end = 3039 \ No newline at end of file + _VALUEEXPR._serialized_end = 3039 diff --git a/edg/edgir/expr_pb2.pyi b/edg/edgir/expr_pb2.pyi index 2d1e15315..5ef2e0b8f 100644 --- a/edg/edgir/expr_pb2.pyi +++ b/edg/edgir/expr_pb2.pyi @@ -25,6 +25,7 @@ in a small number number of places to help classify types into groups. I don't think we should be using sorts at all in this module, but it's defined for the sake on completeness. """ + from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import lit_pb2 as _lit_pb2 @@ -36,6 +37,7 @@ from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -47,62 +49,57 @@ class UnaryExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType('ValueType', _builtins.int) + ValueType = _typing.NewType("ValueType", _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[UnaryExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: UnaryExpr._Op.ValueType NEGATE: UnaryExpr._Op.ValueType - '* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n ' + "* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n " NOT: UnaryExpr._Op.ValueType - '* Not :: Bool -> Bool' + "* Not :: Bool -> Bool" INVERT: UnaryExpr._Op.ValueType - '* Invert :: Float -> Float\n :: Range Float -> Range Float\n ' + "* Invert :: Float -> Float\n :: Range Float -> Range Float\n " MIN: UnaryExpr._Op.ValueType - '* Min :: Range a -> a' + "* Min :: Range a -> a" MAX: UnaryExpr._Op.ValueType - '* Max :: Range a -> a' + "* Max :: Range a -> a" CENTER: UnaryExpr._Op.ValueType - '* Center :: Range a -> a' + "* Center :: Range a -> a" WIDTH: UnaryExpr._Op.ValueType - '* Width :: Range a -> a' + "* Width :: Range a -> a" - class Op(_Op, metaclass=_OpEnumTypeWrapper): - ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): ... UNDEFINED: UnaryExpr.Op.ValueType NEGATE: UnaryExpr.Op.ValueType - '* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n ' + "* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n " NOT: UnaryExpr.Op.ValueType - '* Not :: Bool -> Bool' + "* Not :: Bool -> Bool" INVERT: UnaryExpr.Op.ValueType - '* Invert :: Float -> Float\n :: Range Float -> Range Float\n ' + "* Invert :: Float -> Float\n :: Range Float -> Range Float\n " MIN: UnaryExpr.Op.ValueType - '* Min :: Range a -> a' + "* Min :: Range a -> a" MAX: UnaryExpr.Op.ValueType - '* Max :: Range a -> a' + "* Max :: Range a -> a" CENTER: UnaryExpr.Op.ValueType - '* Center :: Range a -> a' + "* Center :: Range a -> a" WIDTH: UnaryExpr.Op.ValueType - '* Width :: Range a -> a' + "* Width :: Range a -> a" OP_FIELD_NUMBER: _builtins.int VAL_FIELD_NUMBER: _builtins.int op: Global___UnaryExpr.Op.ValueType @_builtins.property - def val(self) -> Global___ValueExpr: - ... + def val(self) -> Global___ValueExpr: ... + def __init__(self, *, op: Global___UnaryExpr.Op.ValueType = ..., val: Global___ValueExpr | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] - def __init__(self, *, op: Global___UnaryExpr.Op.ValueType=..., val: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["op", b"op", "val", b"val"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['op', b'op', 'val', b'val'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___UnaryExpr: _TypeAlias = UnaryExpr @_typing.final @@ -110,86 +107,83 @@ class UnarySetExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType('ValueType', _builtins.int) + ValueType = _typing.NewType("ValueType", _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[UnarySetExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: UnarySetExpr._Op.ValueType SUM: UnarySetExpr._Op.ValueType - '* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n ' + "* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n " ALL_TRUE: UnarySetExpr._Op.ValueType - '* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n ' + "* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n " ANY_TRUE: UnarySetExpr._Op.ValueType - '* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n ' + "* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n " ALL_EQ: UnarySetExpr._Op.ValueType - '* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n ' + "* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n " ALL_UNIQUE: UnarySetExpr._Op.ValueType - '* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n ' + "* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n " MAXIMUM: UnarySetExpr._Op.ValueType - 'SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' + "SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " MINIMUM: UnarySetExpr._Op.ValueType - '* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' + "* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " SET_EXTRACT: UnarySetExpr._Op.ValueType - '* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n ' + "* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n " INTERSECTION: UnarySetExpr._Op.ValueType - '* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n ' + "* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n " HULL: UnarySetExpr._Op.ValueType - '* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n ' + "* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n " NEGATE: UnarySetExpr._Op.ValueType - '* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n ' + "* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n " INVERT: UnarySetExpr._Op.ValueType - '* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n ' + "* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n " FLATTEN: UnarySetExpr._Op.ValueType - 'Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n ' + "Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n " - class Op(_Op, metaclass=_OpEnumTypeWrapper): - ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): ... UNDEFINED: UnarySetExpr.Op.ValueType SUM: UnarySetExpr.Op.ValueType - '* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n ' + "* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n " ALL_TRUE: UnarySetExpr.Op.ValueType - '* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n ' + "* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n " ANY_TRUE: UnarySetExpr.Op.ValueType - '* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n ' + "* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n " ALL_EQ: UnarySetExpr.Op.ValueType - '* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n ' + "* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n " ALL_UNIQUE: UnarySetExpr.Op.ValueType - '* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n ' + "* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n " MAXIMUM: UnarySetExpr.Op.ValueType - 'SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' + "SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " MINIMUM: UnarySetExpr.Op.ValueType - '* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' + "* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " SET_EXTRACT: UnarySetExpr.Op.ValueType - '* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n ' + "* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n " INTERSECTION: UnarySetExpr.Op.ValueType - '* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n ' + "* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n " HULL: UnarySetExpr.Op.ValueType - '* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n ' + "* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n " NEGATE: UnarySetExpr.Op.ValueType - '* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n ' + "* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n " INVERT: UnarySetExpr.Op.ValueType - '* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n ' + "* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n " FLATTEN: UnarySetExpr.Op.ValueType - 'Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n ' + "Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n " OP_FIELD_NUMBER: _builtins.int VALS_FIELD_NUMBER: _builtins.int op: Global___UnarySetExpr.Op.ValueType @_builtins.property - def vals(self) -> Global___ValueExpr: - ... + def vals(self) -> Global___ValueExpr: ... + def __init__( + self, *, op: Global___UnarySetExpr.Op.ValueType = ..., vals: Global___ValueExpr | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["vals", b"vals"] - def __init__(self, *, op: Global___UnarySetExpr.Op.ValueType=..., vals: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['vals', b'vals'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["op", b"op", "vals", b"vals"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['op', b'op', 'vals', b'vals'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___UnarySetExpr: _TypeAlias = UnarySetExpr @_typing.final @@ -197,115 +191,114 @@ class BinaryExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType('ValueType', _builtins.int) + ValueType = _typing.NewType("ValueType", _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[BinaryExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: BinaryExpr._Op.ValueType ADD: BinaryExpr._Op.ValueType - '* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' + "* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " MULT: BinaryExpr._Op.ValueType - 'SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' + "SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " SHRINK_MULT: BinaryExpr._Op.ValueType - 'A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n ' + "A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n " AND: BinaryExpr._Op.ValueType - 'DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n ' + "DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n " OR: BinaryExpr._Op.ValueType - '* Or :: (lhs :: Bool, rhs :: Bool) -> Bool' + "* Or :: (lhs :: Bool, rhs :: Bool) -> Bool" XOR: BinaryExpr._Op.ValueType - '* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool' + "* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool" IMPLIES: BinaryExpr._Op.ValueType - '* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool' + "* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool" EQ: BinaryExpr._Op.ValueType - 'IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n ' + "IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n " NEQ: BinaryExpr._Op.ValueType - '* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool' + "* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool" GT: BinaryExpr._Op.ValueType - '* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" GTE: BinaryExpr._Op.ValueType - '* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" LT: BinaryExpr._Op.ValueType - '* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" LTE: BinaryExpr._Op.ValueType - '* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" MAX: BinaryExpr._Op.ValueType - '* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a' + "* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a" MIN: BinaryExpr._Op.ValueType - '* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a' + "* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a" INTERSECTION: BinaryExpr._Op.ValueType - 'UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n ' + "UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n " HULL: BinaryExpr._Op.ValueType - '* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n ' + "* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n " WITHIN: BinaryExpr._Op.ValueType "INTERSECTS = 52;\n\n * Within :: (Numeric a) => (lhs :: Range a, rhs :: Range a) -> Bool\n :: (Numeric a) => (lhs :: a, rhs :: Range a) -> Bool\n\n Whether the lhs range or point is entirely within (contained by) the rhs.\n Used to be named SUBSET changed to a name that doesn't also imply a set op.\n " RANGE: BinaryExpr._Op.ValueType - '* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a' + "* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a" - class Op(_Op, metaclass=_OpEnumTypeWrapper): - ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): ... UNDEFINED: BinaryExpr.Op.ValueType ADD: BinaryExpr.Op.ValueType - '* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' + "* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " MULT: BinaryExpr.Op.ValueType - 'SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' + "SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " SHRINK_MULT: BinaryExpr.Op.ValueType - 'A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n ' + "A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n " AND: BinaryExpr.Op.ValueType - 'DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n ' + "DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n " OR: BinaryExpr.Op.ValueType - '* Or :: (lhs :: Bool, rhs :: Bool) -> Bool' + "* Or :: (lhs :: Bool, rhs :: Bool) -> Bool" XOR: BinaryExpr.Op.ValueType - '* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool' + "* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool" IMPLIES: BinaryExpr.Op.ValueType - '* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool' + "* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool" EQ: BinaryExpr.Op.ValueType - 'IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n ' + "IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n " NEQ: BinaryExpr.Op.ValueType - '* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool' + "* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool" GT: BinaryExpr.Op.ValueType - '* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" GTE: BinaryExpr.Op.ValueType - '* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" LT: BinaryExpr.Op.ValueType - '* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" LTE: BinaryExpr.Op.ValueType - '* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' + "* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" MAX: BinaryExpr.Op.ValueType - '* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a' + "* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a" MIN: BinaryExpr.Op.ValueType - '* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a' + "* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a" INTERSECTION: BinaryExpr.Op.ValueType - 'UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n ' + "UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n " HULL: BinaryExpr.Op.ValueType - '* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n ' + "* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n " WITHIN: BinaryExpr.Op.ValueType "INTERSECTS = 52;\n\n * Within :: (Numeric a) => (lhs :: Range a, rhs :: Range a) -> Bool\n :: (Numeric a) => (lhs :: a, rhs :: Range a) -> Bool\n\n Whether the lhs range or point is entirely within (contained by) the rhs.\n Used to be named SUBSET changed to a name that doesn't also imply a set op.\n " RANGE: BinaryExpr.Op.ValueType - '* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a' + "* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a" OP_FIELD_NUMBER: _builtins.int LHS_FIELD_NUMBER: _builtins.int RHS_FIELD_NUMBER: _builtins.int op: Global___BinaryExpr.Op.ValueType @_builtins.property - def lhs(self) -> Global___ValueExpr: - ... - + def lhs(self) -> Global___ValueExpr: ... @_builtins.property - def rhs(self) -> Global___ValueExpr: - ... + def rhs(self) -> Global___ValueExpr: ... + def __init__( + self, + *, + op: Global___BinaryExpr.Op.ValueType = ..., + lhs: Global___ValueExpr | None = ..., + rhs: Global___ValueExpr | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["lhs", b"lhs", "rhs", b"rhs"] - def __init__(self, *, op: Global___BinaryExpr.Op.ValueType=..., lhs: Global___ValueExpr | None=..., rhs: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['lhs', b'lhs', 'rhs', b'rhs'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["lhs", b"lhs", "op", b"op", "rhs", b"rhs"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['lhs', b'lhs', 'op', b'op', 'rhs', b'rhs'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___BinaryExpr: _TypeAlias = BinaryExpr @_typing.final @@ -313,73 +306,70 @@ class BinarySetExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType('ValueType', _builtins.int) + ValueType = _typing.NewType("ValueType", _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[BinarySetExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: BinarySetExpr._Op.ValueType ADD: BinarySetExpr._Op.ValueType - '* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' + "* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " MULT: BinarySetExpr._Op.ValueType - '* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' + "* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " CONCAT: BinarySetExpr._Op.ValueType - 'String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n ' + "String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n " EQ: BinarySetExpr._Op.ValueType - 'Equality operator\n (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element)\n ' + "Equality operator\n (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element)\n " - class Op(_Op, metaclass=_OpEnumTypeWrapper): - ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): ... UNDEFINED: BinarySetExpr.Op.ValueType ADD: BinarySetExpr.Op.ValueType - '* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' + "* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " MULT: BinarySetExpr.Op.ValueType - '* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' + "* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " CONCAT: BinarySetExpr.Op.ValueType - 'String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n ' + "String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n " EQ: BinarySetExpr.Op.ValueType - 'Equality operator\n (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element)\n ' + "Equality operator\n (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element)\n " OP_FIELD_NUMBER: _builtins.int LHSET_FIELD_NUMBER: _builtins.int RHS_FIELD_NUMBER: _builtins.int op: Global___BinarySetExpr.Op.ValueType @_builtins.property - def lhset(self) -> Global___ValueExpr: - ... - + def lhset(self) -> Global___ValueExpr: ... @_builtins.property - def rhs(self) -> Global___ValueExpr: - ... + def rhs(self) -> Global___ValueExpr: ... + def __init__( + self, + *, + op: Global___BinarySetExpr.Op.ValueType = ..., + lhset: Global___ValueExpr | None = ..., + rhs: Global___ValueExpr | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["lhset", b"lhset", "rhs", b"rhs"] - def __init__(self, *, op: Global___BinarySetExpr.Op.ValueType=..., lhset: Global___ValueExpr | None=..., rhs: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['lhset', b'lhset', 'rhs', b'rhs'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["lhset", b"lhset", "op", b"op", "rhs", b"rhs"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['lhset', b'lhset', 'op', b'op', 'rhs', b'rhs'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___BinarySetExpr: _TypeAlias = BinarySetExpr @_typing.final class ArrayExpr(_message.Message): """* Creates an array from element exprs""" + DESCRIPTOR: _descriptor.Descriptor VALS_FIELD_NUMBER: _builtins.int @_builtins.property - def vals(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueExpr]: - ... + def vals(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueExpr]: ... + def __init__(self, *, vals: _abc.Iterable[Global___ValueExpr] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["vals", b"vals"] - def __init__(self, *, vals: _abc.Iterable[Global___ValueExpr] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['vals', b'vals'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ArrayExpr: _TypeAlias = ArrayExpr @_typing.final @@ -387,28 +377,25 @@ class RangeExpr(_message.Message): """* Ranges have an expression form, allowing you to constrain them without specifying them fully """ + DESCRIPTOR: _descriptor.Descriptor MINIMUM_FIELD_NUMBER: _builtins.int MAXIMUM_FIELD_NUMBER: _builtins.int @_builtins.property - def minimum(self) -> Global___ValueExpr: - ... - + def minimum(self) -> Global___ValueExpr: ... @_builtins.property - def maximum(self) -> Global___ValueExpr: - ... + def maximum(self) -> Global___ValueExpr: ... + def __init__( + self, *, minimum: Global___ValueExpr | None = ..., maximum: Global___ValueExpr | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] - def __init__(self, *, minimum: Global___ValueExpr | None=..., maximum: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___RangeExpr: _TypeAlias = RangeExpr @_typing.final @@ -416,6 +403,7 @@ class StructExpr(_message.Message): """* Structs have an expression form, allowing you to constrain them without specifying them fully """ + DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -426,36 +414,30 @@ class StructExpr(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___ValueExpr: - ... + def value(self) -> Global___ValueExpr: ... + def __init__(self, *, key: _builtins.str = ..., value: Global___ValueExpr | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, key: _builtins.str=..., value: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... VALS_FIELD_NUMBER: _builtins.int @_builtins.property - def vals(self) -> _containers.MessageMap[_builtins.str, Global___ValueExpr]: - ... + def vals(self) -> _containers.MessageMap[_builtins.str, Global___ValueExpr]: ... + def __init__(self, *, vals: _abc.Mapping[_builtins.str, Global___ValueExpr] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["vals", b"vals"] - def __init__(self, *, vals: _abc.Mapping[_builtins.str, Global___ValueExpr] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['vals', b'vals'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___StructExpr: _TypeAlias = StructExpr @_typing.final class IfThenElseExpr(_message.Message): """* IfThenElse :: (cond :: Bool, tru :: a, fal :: a) -> a""" + DESCRIPTOR: _descriptor.Descriptor COND_FIELD_NUMBER: _builtins.int TRU_FIELD_NUMBER: _builtins.int @@ -463,31 +445,28 @@ class IfThenElseExpr(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def cond(self) -> Global___ValueExpr: - ... - + def cond(self) -> Global___ValueExpr: ... @_builtins.property - def tru(self) -> Global___ValueExpr: - ... - + def tru(self) -> Global___ValueExpr: ... @_builtins.property - def fal(self) -> Global___ValueExpr: - ... - + def fal(self) -> Global___ValueExpr: ... @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + cond: Global___ValueExpr | None = ..., + tru: Global___ValueExpr | None = ..., + fal: Global___ValueExpr | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["cond", b"cond", "fal", b"fal", "meta", b"meta", "tru", b"tru"] - def __init__(self, *, cond: Global___ValueExpr | None=..., tru: Global___ValueExpr | None=..., fal: Global___ValueExpr | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['cond', b'cond', 'fal', b'fal', 'meta', b'meta', 'tru', b'tru'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["cond", b"cond", "fal", b"fal", "meta", b"meta", "tru", b"tru"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['cond', b'cond', 'fal', b'fal', 'meta', b'meta', 'tru', b'tru'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___IfThenElseExpr: _TypeAlias = IfThenElseExpr @_typing.final @@ -496,60 +475,54 @@ class ExtractExpr(_message.Message): Extract :: (container :: Struct{index :: a}, index :: string) -> a Extract :: (container :: Range a , index :: {"minimum"|"maximum"}) -> a """ + DESCRIPTOR: _descriptor.Descriptor CONTAINER_FIELD_NUMBER: _builtins.int INDEX_FIELD_NUMBER: _builtins.int @_builtins.property - def container(self) -> Global___ValueExpr: - ... - + def container(self) -> Global___ValueExpr: ... @_builtins.property - def index(self) -> Global___ValueExpr: - ... + def index(self) -> Global___ValueExpr: ... + def __init__( + self, *, container: Global___ValueExpr | None = ..., index: Global___ValueExpr | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "index", b"index"] - def __init__(self, *, container: Global___ValueExpr | None=..., index: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'index', b'index'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "index", b"index"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'index', b'index'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ExtractExpr: _TypeAlias = ExtractExpr @_typing.final class MapExtractExpr(_message.Message): """/** MapExtract :: (container :: Array a , path :: LocalRef{from :: a, to :: b}) -> Array b - MapExtract :: (container :: Set a , path :: LocalRef{from :: a, to :: b}) -> Set b + MapExtract :: (container :: Set a , path :: LocalRef{from :: a, to :: b}) -> Set b - This expression can map over a container and return a container of - the relevant subexpression determined by a path. */ + This expression can map over a container and return a container of + the relevant subexpression determined by a path. */ """ + DESCRIPTOR: _descriptor.Descriptor CONTAINER_FIELD_NUMBER: _builtins.int PATH_FIELD_NUMBER: _builtins.int @_builtins.property - def container(self) -> Global___ValueExpr: - ... - + def container(self) -> Global___ValueExpr: ... @_builtins.property - def path(self) -> _ref_pb2.LocalPath: - ... + def path(self) -> _ref_pb2.LocalPath: ... + def __init__( + self, *, container: Global___ValueExpr | None = ..., path: _ref_pb2.LocalPath | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "path", b"path"] - def __init__(self, *, container: Global___ValueExpr | None=..., path: _ref_pb2.LocalPath | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'path', b'path'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "path", b"path"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'path', b'path'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___MapExtractExpr: _TypeAlias = MapExtractExpr @_typing.final @@ -558,19 +531,16 @@ class ConnectedExpr(_message.Message): This tells us whether the specified ports are connected """ + DESCRIPTOR: _descriptor.Descriptor BLOCK_PORT_FIELD_NUMBER: _builtins.int LINK_PORT_FIELD_NUMBER: _builtins.int EXPANDED_FIELD_NUMBER: _builtins.int @_builtins.property - def block_port(self) -> Global___ValueExpr: - ... - + def block_port(self) -> Global___ValueExpr: ... @_builtins.property - def link_port(self) -> Global___ValueExpr: - ... - + def link_port(self) -> Global___ValueExpr: ... @_builtins.property def expanded(self) -> _containers.RepeatedCompositeFieldContainer[Global___ConnectedExpr]: """During compilation, ConnectedExpr may be expanded (allocate replaced with concrete path indices, @@ -579,16 +549,22 @@ class ConnectedExpr(_message.Message): while the original (parent) is not modified. """ - def __init__(self, *, block_port: Global___ValueExpr | None=..., link_port: Global___ValueExpr | None=..., expanded: _abc.Iterable[Global___ConnectedExpr] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['block_port', b'block_port', 'link_port', b'link_port'] + def __init__( + self, + *, + block_port: Global___ValueExpr | None = ..., + link_port: Global___ValueExpr | None = ..., + expanded: _abc.Iterable[Global___ConnectedExpr] | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["block_port", b"block_port", "link_port", b"link_port"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "block_port", b"block_port", "expanded", b"expanded", "link_port", b"link_port" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['block_port', b'block_port', 'expanded', b'expanded', 'link_port', b'link_port'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ConnectedExpr: _TypeAlias = ConnectedExpr @_typing.final @@ -597,33 +573,38 @@ class ExportedExpr(_message.Message): This tells us whether the specified port is exported to the hierarchy block exterior port """ + DESCRIPTOR: _descriptor.Descriptor EXTERIOR_PORT_FIELD_NUMBER: _builtins.int INTERNAL_BLOCK_PORT_FIELD_NUMBER: _builtins.int EXPANDED_FIELD_NUMBER: _builtins.int @_builtins.property - def exterior_port(self) -> Global___ValueExpr: - ... - + def exterior_port(self) -> Global___ValueExpr: ... @_builtins.property - def internal_block_port(self) -> Global___ValueExpr: - ... - + def internal_block_port(self) -> Global___ValueExpr: ... @_builtins.property def expanded(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExportedExpr]: """see comment in ConnectedExpr""" - def __init__(self, *, exterior_port: Global___ValueExpr | None=..., internal_block_port: Global___ValueExpr | None=..., expanded: _abc.Iterable[Global___ExportedExpr] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['exterior_port', b'exterior_port', 'internal_block_port', b'internal_block_port'] + def __init__( + self, + *, + exterior_port: Global___ValueExpr | None = ..., + internal_block_port: Global___ValueExpr | None = ..., + expanded: _abc.Iterable[Global___ExportedExpr] | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "exterior_port", b"exterior_port", "internal_block_port", b"internal_block_port" + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "expanded", b"expanded", "exterior_port", b"exterior_port", "internal_block_port", b"internal_block_port" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['expanded', b'expanded', 'exterior_port', b'exterior_port', 'internal_block_port', b'internal_block_port'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ExportedExpr: _TypeAlias = ExportedExpr @_typing.final @@ -631,28 +612,23 @@ class AssignExpr(_message.Message): """Variable assignment (from an expression value), which allows dataflow to be directioned and explicit. Assignments should not be cyclic. """ + DESCRIPTOR: _descriptor.Descriptor DST_FIELD_NUMBER: _builtins.int SRC_FIELD_NUMBER: _builtins.int @_builtins.property - def dst(self) -> _ref_pb2.LocalPath: - ... - + def dst(self) -> _ref_pb2.LocalPath: ... @_builtins.property - def src(self) -> Global___ValueExpr: - ... + def src(self) -> Global___ValueExpr: ... + def __init__(self, *, dst: _ref_pb2.LocalPath | None = ..., src: Global___ValueExpr | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["dst", b"dst", "src", b"src"] - def __init__(self, *, dst: _ref_pb2.LocalPath | None=..., src: Global___ValueExpr | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['dst', b'dst', 'src', b'src'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["dst", b"dst", "src", b"src"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['dst', b'dst', 'src', b'src'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___AssignExpr: _TypeAlias = AssignExpr @_typing.final @@ -680,49 +656,29 @@ class ValueExpr(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def literal(self) -> _lit_pb2.ValueLit: - ... - + def literal(self) -> _lit_pb2.ValueLit: ... @_builtins.property - def binary(self) -> Global___BinaryExpr: - ... - + def binary(self) -> Global___BinaryExpr: ... @_builtins.property - def binary_set(self) -> Global___BinarySetExpr: - ... - + def binary_set(self) -> Global___BinarySetExpr: ... @_builtins.property - def unary(self) -> Global___UnaryExpr: - ... - + def unary(self) -> Global___UnaryExpr: ... @_builtins.property - def unary_set(self) -> Global___UnarySetExpr: - ... - + def unary_set(self) -> Global___UnarySetExpr: ... @_builtins.property def array(self) -> Global___ArrayExpr: """SetExpr set = 5;""" @_builtins.property - def struct(self) -> Global___StructExpr: - ... - + def struct(self) -> Global___StructExpr: ... @_builtins.property - def range(self) -> Global___RangeExpr: - ... - + def range(self) -> Global___RangeExpr: ... @_builtins.property - def ifThenElse(self) -> Global___IfThenElseExpr: - ... - + def ifThenElse(self) -> Global___IfThenElseExpr: ... @_builtins.property - def extract(self) -> Global___ExtractExpr: - ... - + def extract(self) -> Global___ExtractExpr: ... @_builtins.property - def map_extract(self) -> Global___MapExtractExpr: - ... - + def map_extract(self) -> Global___MapExtractExpr: ... @_builtins.property def connected(self) -> Global___ConnectedExpr: """single port to single port connect""" @@ -740,9 +696,7 @@ class ValueExpr(_message.Message): """array to array export, where allocate means allocate a subarray""" @_builtins.property - def assign(self) -> Global___AssignExpr: - ... - + def assign(self) -> Global___AssignExpr: ... @_builtins.property def exportedTunnel(self) -> Global___ExportedExpr: """These Exprs support cross-hierarchy operations @@ -764,26 +718,148 @@ class ValueExpr(_message.Message): """ @_builtins.property - def ref(self) -> _ref_pb2.LocalPath: - ... - - @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... - - def __init__(self, *, literal: _lit_pb2.ValueLit | None=..., binary: Global___BinaryExpr | None=..., binary_set: Global___BinarySetExpr | None=..., unary: Global___UnaryExpr | None=..., unary_set: Global___UnarySetExpr | None=..., array: Global___ArrayExpr | None=..., struct: Global___StructExpr | None=..., range: Global___RangeExpr | None=..., ifThenElse: Global___IfThenElseExpr | None=..., extract: Global___ExtractExpr | None=..., map_extract: Global___MapExtractExpr | None=..., connected: Global___ConnectedExpr | None=..., exported: Global___ExportedExpr | None=..., connectedArray: Global___ConnectedExpr | None=..., exportedArray: Global___ExportedExpr | None=..., assign: Global___AssignExpr | None=..., exportedTunnel: Global___ExportedExpr | None=..., assignTunnel: Global___AssignExpr | None=..., ref: _ref_pb2.LocalPath | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'assign', b'assign', 'assignTunnel', b'assignTunnel', 'binary', b'binary', 'binary_set', b'binary_set', 'connected', b'connected', 'connectedArray', b'connectedArray', 'exported', b'exported', 'exportedArray', b'exportedArray', 'exportedTunnel', b'exportedTunnel', 'expr', b'expr', 'extract', b'extract', 'ifThenElse', b'ifThenElse', 'literal', b'literal', 'map_extract', b'map_extract', 'meta', b'meta', 'range', b'range', 'ref', b'ref', 'struct', b'struct', 'unary', b'unary', 'unary_set', b'unary_set'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'assign', b'assign', 'assignTunnel', b'assignTunnel', 'binary', b'binary', 'binary_set', b'binary_set', 'connected', b'connected', 'connectedArray', b'connectedArray', 'exported', b'exported', 'exportedArray', b'exportedArray', 'exportedTunnel', b'exportedTunnel', 'expr', b'expr', 'extract', b'extract', 'ifThenElse', b'ifThenElse', 'literal', b'literal', 'map_extract', b'map_extract', 'meta', b'meta', 'range', b'range', 'ref', b'ref', 'struct', b'struct', 'unary', b'unary', 'unary_set', b'unary_set'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_expr: _TypeAlias = _typing.Literal['literal', 'binary', 'binary_set', 'unary', 'unary_set', 'array', 'struct', 'range', 'ifThenElse', 'extract', 'map_extract', 'connected', 'exported', 'connectedArray', 'exportedArray', 'assign', 'exportedTunnel', 'assignTunnel', 'ref'] - _WhichOneofArgType_expr: _TypeAlias = _typing.Literal['expr', b'expr'] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_expr) -> _WhichOneofReturnType_expr | None: - ... -Global___ValueExpr: _TypeAlias = ValueExpr \ No newline at end of file + def ref(self) -> _ref_pb2.LocalPath: ... + @_builtins.property + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + literal: _lit_pb2.ValueLit | None = ..., + binary: Global___BinaryExpr | None = ..., + binary_set: Global___BinarySetExpr | None = ..., + unary: Global___UnaryExpr | None = ..., + unary_set: Global___UnarySetExpr | None = ..., + array: Global___ArrayExpr | None = ..., + struct: Global___StructExpr | None = ..., + range: Global___RangeExpr | None = ..., + ifThenElse: Global___IfThenElseExpr | None = ..., + extract: Global___ExtractExpr | None = ..., + map_extract: Global___MapExtractExpr | None = ..., + connected: Global___ConnectedExpr | None = ..., + exported: Global___ExportedExpr | None = ..., + connectedArray: Global___ConnectedExpr | None = ..., + exportedArray: Global___ExportedExpr | None = ..., + assign: Global___AssignExpr | None = ..., + exportedTunnel: Global___ExportedExpr | None = ..., + assignTunnel: Global___AssignExpr | None = ..., + ref: _ref_pb2.LocalPath | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "array", + b"array", + "assign", + b"assign", + "assignTunnel", + b"assignTunnel", + "binary", + b"binary", + "binary_set", + b"binary_set", + "connected", + b"connected", + "connectedArray", + b"connectedArray", + "exported", + b"exported", + "exportedArray", + b"exportedArray", + "exportedTunnel", + b"exportedTunnel", + "expr", + b"expr", + "extract", + b"extract", + "ifThenElse", + b"ifThenElse", + "literal", + b"literal", + "map_extract", + b"map_extract", + "meta", + b"meta", + "range", + b"range", + "ref", + b"ref", + "struct", + b"struct", + "unary", + b"unary", + "unary_set", + b"unary_set", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "array", + b"array", + "assign", + b"assign", + "assignTunnel", + b"assignTunnel", + "binary", + b"binary", + "binary_set", + b"binary_set", + "connected", + b"connected", + "connectedArray", + b"connectedArray", + "exported", + b"exported", + "exportedArray", + b"exportedArray", + "exportedTunnel", + b"exportedTunnel", + "expr", + b"expr", + "extract", + b"extract", + "ifThenElse", + b"ifThenElse", + "literal", + b"literal", + "map_extract", + b"map_extract", + "meta", + b"meta", + "range", + b"range", + "ref", + b"ref", + "struct", + b"struct", + "unary", + b"unary", + "unary_set", + b"unary_set", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_expr: _TypeAlias = _typing.Literal[ + "literal", + "binary", + "binary_set", + "unary", + "unary_set", + "array", + "struct", + "range", + "ifThenElse", + "extract", + "map_extract", + "connected", + "exported", + "connectedArray", + "exportedArray", + "assign", + "exportedTunnel", + "assignTunnel", + "ref", + ] + _WhichOneofArgType_expr: _TypeAlias = _typing.Literal["expr", b"expr"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_expr) -> _WhichOneofReturnType_expr | None: ... + +Global___ValueExpr: _TypeAlias = ValueExpr diff --git a/edg/edgir/impl_pb2.py b/edg/edgir/impl_pb2.py index 47e51e529..2392b5cbe 100644 --- a/edg/edgir/impl_pb2.py +++ b/edg/edgir/impl_pb2.py @@ -1,13 +1,18 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/impl.proto\x12\nedgir.impl\x1a\x12edgir/common.proto"1\n\tBlockImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08PortImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08LinkImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"7\n\x0fEnvironmentImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x10edgir/impl.proto\x12\nedgir.impl\x1a\x12edgir/common.proto"1\n\tBlockImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08PortImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08LinkImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"7\n\x0fEnvironmentImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.impl_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.impl_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _BLOCKIMPL._serialized_start = 52 @@ -17,4 +22,4 @@ _LINKIMPL._serialized_start = 153 _LINKIMPL._serialized_end = 201 _ENVIRONMENTIMPL._serialized_start = 203 - _ENVIRONMENTIMPL._serialized_end = 258 \ No newline at end of file + _ENVIRONMENTIMPL._serialized_end = 258 diff --git a/edg/edgir/impl_pb2.pyi b/edg/edgir/impl_pb2.pyi index a38a4ffdd..3169fd28a 100644 --- a/edg/edgir/impl_pb2.pyi +++ b/edg/edgir/impl_pb2.pyi @@ -10,12 +10,14 @@ stored. Fuck if I know what that will look like, so for now you just get a metadata block. """ + from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -28,19 +30,15 @@ class BlockImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___BlockImpl: _TypeAlias = BlockImpl @_typing.final @@ -49,19 +47,15 @@ class PortImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___PortImpl: _TypeAlias = PortImpl @_typing.final @@ -70,19 +64,15 @@ class LinkImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___LinkImpl: _TypeAlias = LinkImpl @_typing.final @@ -91,17 +81,13 @@ class EnvironmentImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... -Global___EnvironmentImpl: _TypeAlias = EnvironmentImpl \ No newline at end of file +Global___EnvironmentImpl: _TypeAlias = EnvironmentImpl diff --git a/edg/edgir/init_pb2.py b/edg/edgir/init_pb2.py index 92571bac8..6b6964627 100644 --- a/edg/edgir/init_pb2.py +++ b/edg/edgir/init_pb2.py @@ -1,14 +1,19 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/init.proto\x12\nedgir.init\x1a\x12edgir/common.proto"\xeb\x02\n\x07ValInit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07integer\x18\x02 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07boolean\x18\x03 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12#\n\x04text\x18\x04 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12"\n\x03set\x18\x08 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12%\n\x06struct\x18\t \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.init.ValInitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x05\n\x03valb\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x10edgir/init.proto\x12\nedgir.init\x1a\x12edgir/common.proto"\xeb\x02\n\x07ValInit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07integer\x18\x02 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07boolean\x18\x03 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12#\n\x04text\x18\x04 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12"\n\x03set\x18\x08 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12%\n\x06struct\x18\t \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.init.ValInitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x05\n\x03valb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.init_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.init_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _VALINIT._serialized_start = 53 - _VALINIT._serialized_end = 416 \ No newline at end of file + _VALINIT._serialized_end = 416 diff --git a/edg/edgir/init_pb2.pyi b/edg/edgir/init_pb2.pyi index 534446937..dce1504c7 100644 --- a/edg/edgir/init_pb2.pyi +++ b/edg/edgir/init_pb2.pyi @@ -11,12 +11,14 @@ creating a value. FIXME :: Does this make more sense in another file? """ + from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -30,6 +32,7 @@ class ValInit(_message.Message): I think the frontend should have more type specific wrappers around this since the data required for each type can be different. """ + DESCRIPTOR: _descriptor.Descriptor FLOATING_FIELD_NUMBER: _builtins.int INTEGER_FIELD_NUMBER: _builtins.int @@ -42,54 +45,89 @@ class ValInit(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def floating(self) -> _common_pb2.Empty: - ... - + def floating(self) -> _common_pb2.Empty: ... @_builtins.property - def integer(self) -> _common_pb2.Empty: - ... - + def integer(self) -> _common_pb2.Empty: ... @_builtins.property - def boolean(self) -> _common_pb2.Empty: - ... - + def boolean(self) -> _common_pb2.Empty: ... @_builtins.property - def text(self) -> _common_pb2.Empty: - ... - + def text(self) -> _common_pb2.Empty: ... @_builtins.property - def set(self) -> _common_pb2.Empty: - ... - + def set(self) -> _common_pb2.Empty: ... @_builtins.property - def struct(self) -> _common_pb2.Empty: - ... - + def struct(self) -> _common_pb2.Empty: ... @_builtins.property - def range(self) -> _common_pb2.Empty: - ... - + def range(self) -> _common_pb2.Empty: ... @_builtins.property - def array(self) -> Global___ValInit: - ... - + def array(self) -> Global___ValInit: ... @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... - - def __init__(self, *, floating: _common_pb2.Empty | None=..., integer: _common_pb2.Empty | None=..., boolean: _common_pb2.Empty | None=..., text: _common_pb2.Empty | None=..., set: _common_pb2.Empty | None=..., struct: _common_pb2.Empty | None=..., range: _common_pb2.Empty | None=..., array: Global___ValInit | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'set', b'set', 'struct', b'struct', 'text', b'text', 'val', b'val'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'set', b'set', 'struct', b'struct', 'text', b'text', 'val', b'val'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_val: _TypeAlias = _typing.Literal['floating', 'integer', 'boolean', 'text', 'set', 'struct', 'range', 'array'] - _WhichOneofArgType_val: _TypeAlias = _typing.Literal['val', b'val'] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_val) -> _WhichOneofReturnType_val | None: - ... -Global___ValInit: _TypeAlias = ValInit \ No newline at end of file + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + floating: _common_pb2.Empty | None = ..., + integer: _common_pb2.Empty | None = ..., + boolean: _common_pb2.Empty | None = ..., + text: _common_pb2.Empty | None = ..., + set: _common_pb2.Empty | None = ..., + struct: _common_pb2.Empty | None = ..., + range: _common_pb2.Empty | None = ..., + array: Global___ValInit | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "array", + b"array", + "boolean", + b"boolean", + "floating", + b"floating", + "integer", + b"integer", + "meta", + b"meta", + "range", + b"range", + "set", + b"set", + "struct", + b"struct", + "text", + b"text", + "val", + b"val", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "array", + b"array", + "boolean", + b"boolean", + "floating", + b"floating", + "integer", + b"integer", + "meta", + b"meta", + "range", + b"range", + "set", + b"set", + "struct", + b"struct", + "text", + b"text", + "val", + b"val", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_val: _TypeAlias = _typing.Literal[ + "floating", "integer", "boolean", "text", "set", "struct", "range", "array" + ] + _WhichOneofArgType_val: _TypeAlias = _typing.Literal["val", b"val"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_val) -> _WhichOneofReturnType_val | None: ... + +Global___ValInit: _TypeAlias = ValInit diff --git a/edg/edgir/lit_pb2.py b/edg/edgir/lit_pb2.py index 96d84789c..5fa7a1533 100644 --- a/edg/edgir/lit_pb2.py +++ b/edg/edgir/lit_pb2.py @@ -1,17 +1,22 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0fedgir/lit.proto\x12\tedgir.lit\x1a\x12edgir/common.proto"\x17\n\x08FloatLit\x12\x0b\n\x03val\x18\x01 \x01(\x01"\x15\n\x06IntLit\x12\x0b\n\x03val\x18\x01 \x01(\x12"\x16\n\x07BoolLit\x12\x0b\n\x03val\x18\x01 \x01(\x08"\x16\n\x07TextLit\x12\x0b\n\x03val\x18\x01 \x01(\t"V\n\x08RangeLit\x12$\n\x07minimum\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLit\x12$\n\x07maximum\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"\x84\x01\n\tStructLit\x122\n\x07members\x18\x01 \x03(\x0b2!.edgir.lit.StructLit.MembersEntry\x1aC\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit:\x028\x01"-\n\x08ArrayLit\x12!\n\x04elts\x18\x01 \x03(\x0b2\x13.edgir.lit.ValueLit"\xc6\x02\n\x08ValueLit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.lit.FloatLitH\x00\x12$\n\x07integer\x18\x02 \x01(\x0b2\x11.edgir.lit.IntLitH\x00\x12%\n\x07boolean\x18\x03 \x01(\x0b2\x12.edgir.lit.BoolLitH\x00\x12"\n\x04text\x18\x04 \x01(\x0b2\x12.edgir.lit.TextLitH\x00\x12&\n\x06struct\x18\t \x01(\x0b2\x14.edgir.lit.StructLitH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.lit.RangeLitH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.lit.ArrayLitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04typeb\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x0fedgir/lit.proto\x12\tedgir.lit\x1a\x12edgir/common.proto"\x17\n\x08FloatLit\x12\x0b\n\x03val\x18\x01 \x01(\x01"\x15\n\x06IntLit\x12\x0b\n\x03val\x18\x01 \x01(\x12"\x16\n\x07BoolLit\x12\x0b\n\x03val\x18\x01 \x01(\x08"\x16\n\x07TextLit\x12\x0b\n\x03val\x18\x01 \x01(\t"V\n\x08RangeLit\x12$\n\x07minimum\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLit\x12$\n\x07maximum\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"\x84\x01\n\tStructLit\x122\n\x07members\x18\x01 \x03(\x0b2!.edgir.lit.StructLit.MembersEntry\x1aC\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit:\x028\x01"-\n\x08ArrayLit\x12!\n\x04elts\x18\x01 \x03(\x0b2\x13.edgir.lit.ValueLit"\xc6\x02\n\x08ValueLit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.lit.FloatLitH\x00\x12$\n\x07integer\x18\x02 \x01(\x0b2\x11.edgir.lit.IntLitH\x00\x12%\n\x07boolean\x18\x03 \x01(\x0b2\x12.edgir.lit.BoolLitH\x00\x12"\n\x04text\x18\x04 \x01(\x0b2\x12.edgir.lit.TextLitH\x00\x12&\n\x06struct\x18\t \x01(\x0b2\x14.edgir.lit.StructLitH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.lit.RangeLitH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.lit.ArrayLitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04typeb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.lit_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.lit_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _STRUCTLIT_MEMBERSENTRY._options = None - _STRUCTLIT_MEMBERSENTRY._serialized_options = b'8\x01' + _STRUCTLIT_MEMBERSENTRY._serialized_options = b"8\x01" _FLOATLIT._serialized_start = 50 _FLOATLIT._serialized_end = 73 _INTLIT._serialized_start = 75 @@ -29,4 +34,4 @@ _ARRAYLIT._serialized_start = 369 _ARRAYLIT._serialized_end = 414 _VALUELIT._serialized_start = 417 - _VALUELIT._serialized_end = 743 \ No newline at end of file + _VALUELIT._serialized_end = 743 diff --git a/edg/edgir/lit_pb2.pyi b/edg/edgir/lit_pb2.pyi index 7d821ab3c..1ed644162 100644 --- a/edg/edgir/lit_pb2.pyi +++ b/edg/edgir/lit_pb2.pyi @@ -7,6 +7,7 @@ Package : edg.lit Literals for assorted priitive types, i.e fixed constant values. """ + from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor @@ -15,6 +16,7 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -26,16 +28,16 @@ class FloatLit(_message.Message): """* The core expression primitives we start with are the value literals that we can use """ + DESCRIPTOR: _descriptor.Descriptor VAL_FIELD_NUMBER: _builtins.int val: _builtins.float - def __init__(self, *, val: _builtins.float=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def __init__(self, *, val: _builtins.float = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___FloatLit: _TypeAlias = FloatLit @_typing.final @@ -44,12 +46,11 @@ class IntLit(_message.Message): VAL_FIELD_NUMBER: _builtins.int val: _builtins.int - def __init__(self, *, val: _builtins.int=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def __init__(self, *, val: _builtins.int = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___IntLit: _TypeAlias = IntLit @_typing.final @@ -58,12 +59,11 @@ class BoolLit(_message.Message): VAL_FIELD_NUMBER: _builtins.int val: _builtins.bool - def __init__(self, *, val: _builtins.bool=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def __init__(self, *, val: _builtins.bool = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___BoolLit: _TypeAlias = BoolLit @_typing.final @@ -72,12 +72,11 @@ class TextLit(_message.Message): VAL_FIELD_NUMBER: _builtins.int val: _builtins.str - def __init__(self, *, val: _builtins.str=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def __init__(self, *, val: _builtins.str = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___TextLit: _TypeAlias = TextLit @_typing.final @@ -87,23 +86,17 @@ class RangeLit(_message.Message): MAXIMUM_FIELD_NUMBER: _builtins.int @_builtins.property - def minimum(self) -> Global___ValueLit: - ... - + def minimum(self) -> Global___ValueLit: ... @_builtins.property - def maximum(self) -> Global___ValueLit: - ... + def maximum(self) -> Global___ValueLit: ... + def __init__(self, *, minimum: Global___ValueLit | None = ..., maximum: Global___ValueLit | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] - def __init__(self, *, minimum: Global___ValueLit | None=..., maximum: Global___ValueLit | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___RangeLit: _TypeAlias = RangeLit @_typing.final @@ -118,31 +111,24 @@ class StructLit(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___ValueLit: - ... + def value(self) -> Global___ValueLit: ... + def __init__(self, *, key: _builtins.str = ..., value: Global___ValueLit | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, key: _builtins.str=..., value: Global___ValueLit | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... MEMBERS_FIELD_NUMBER: _builtins.int @_builtins.property - def members(self) -> _containers.MessageMap[_builtins.str, Global___ValueLit]: - ... + def members(self) -> _containers.MessageMap[_builtins.str, Global___ValueLit]: ... + def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___ValueLit] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["members", b"members"] - def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___ValueLit] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['members', b'members'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___StructLit: _TypeAlias = StructLit @_typing.final @@ -151,15 +137,12 @@ class ArrayLit(_message.Message): ELTS_FIELD_NUMBER: _builtins.int @_builtins.property - def elts(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueLit]: - ... + def elts(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueLit]: ... + def __init__(self, *, elts: _abc.Iterable[Global___ValueLit] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["elts", b"elts"] - def __init__(self, *, elts: _abc.Iterable[Global___ValueLit] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['elts', b'elts'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ArrayLit: _TypeAlias = ArrayLit @_typing.final @@ -175,50 +158,82 @@ class ValueLit(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def floating(self) -> Global___FloatLit: - ... - + def floating(self) -> Global___FloatLit: ... @_builtins.property - def integer(self) -> Global___IntLit: - ... - + def integer(self) -> Global___IntLit: ... @_builtins.property - def boolean(self) -> Global___BoolLit: - ... - + def boolean(self) -> Global___BoolLit: ... @_builtins.property - def text(self) -> Global___TextLit: - ... - + def text(self) -> Global___TextLit: ... @_builtins.property - def struct(self) -> Global___StructLit: - ... - + def struct(self) -> Global___StructLit: ... @_builtins.property - def range(self) -> Global___RangeLit: - ... - + def range(self) -> Global___RangeLit: ... @_builtins.property - def array(self) -> Global___ArrayLit: - ... - + def array(self) -> Global___ArrayLit: ... @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... - - def __init__(self, *, floating: Global___FloatLit | None=..., integer: Global___IntLit | None=..., boolean: Global___BoolLit | None=..., text: Global___TextLit | None=..., struct: Global___StructLit | None=..., range: Global___RangeLit | None=..., array: Global___ArrayLit | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'struct', b'struct', 'text', b'text', 'type', b'type'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'struct', b'struct', 'text', b'text', 'type', b'type'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['floating', 'integer', 'boolean', 'text', 'struct', 'range', 'array'] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: - ... -Global___ValueLit: _TypeAlias = ValueLit \ No newline at end of file + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + floating: Global___FloatLit | None = ..., + integer: Global___IntLit | None = ..., + boolean: Global___BoolLit | None = ..., + text: Global___TextLit | None = ..., + struct: Global___StructLit | None = ..., + range: Global___RangeLit | None = ..., + array: Global___ArrayLit | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "array", + b"array", + "boolean", + b"boolean", + "floating", + b"floating", + "integer", + b"integer", + "meta", + b"meta", + "range", + b"range", + "struct", + b"struct", + "text", + b"text", + "type", + b"type", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "array", + b"array", + "boolean", + b"boolean", + "floating", + b"floating", + "integer", + b"integer", + "meta", + b"meta", + "range", + b"range", + "struct", + b"struct", + "text", + b"text", + "type", + b"type", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal[ + "floating", "integer", "boolean", "text", "struct", "range", "array" + ] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... + +Global___ValueLit: _TypeAlias = ValueLit diff --git a/edg/edgir/name_pb2.py b/edg/edgir/name_pb2.py index 1b64ac05f..5d32702a7 100644 --- a/edg/edgir/name_pb2.py +++ b/edg/edgir/name_pb2.py @@ -1,16 +1,21 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/name.proto\x12\nedgir.name\x1a\x12edgir/common.proto"O\n\tNamespace\x12\x0f\n\x05basic\x18\x01 \x01(\tH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x0b\n\tnamespace"A\n\x0bLibraryName\x12\x0c\n\x04name\x18\x02 \x01(\t\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x10edgir/name.proto\x12\nedgir.name\x1a\x12edgir/common.proto"O\n\tNamespace\x12\x0f\n\x05basic\x18\x01 \x01(\tH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x0b\n\tnamespace"A\n\x0bLibraryName\x12\x0c\n\x04name\x18\x02 \x01(\t\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.name_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.name_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _NAMESPACE._serialized_start = 52 _NAMESPACE._serialized_end = 131 _LIBRARYNAME._serialized_start = 133 - _LIBRARYNAME._serialized_end = 198 \ No newline at end of file + _LIBRARYNAME._serialized_end = 198 diff --git a/edg/edgir/name_pb2.pyi b/edg/edgir/name_pb2.pyi index 50564b2fe..5b30f799c 100644 --- a/edg/edgir/name_pb2.pyi +++ b/edg/edgir/name_pb2.pyi @@ -10,12 +10,14 @@ There are three major classes of name in edg: - LocalNames, which help organize elements relative to each other. - LibraryNames, which we use to identify specific libraries. """ + from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -29,6 +31,7 @@ class Namespace(_message.Message): over items in the library. It lets us group elements in categories that are orthogonal to the usual Block, Port, Link, ontology. """ + DESCRIPTOR: _descriptor.Descriptor BASIC_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @@ -36,24 +39,19 @@ class Namespace(_message.Message): "* Basic namespaces are a way to organize library elements into a\n useful hirearchy (e.g. 'Core.*' for the most primitive definitions\n that we define, or 'NXP.*' for NXP made components.)\n\n Basic namespaces should have the following properties:\n\n - First char is a capital letter\n - All other chars must be letters, numbers, '-', '<', '>'\n - CamelCase is preffered, don't use any symbols in the name\n if possible.\n " @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__(self, *, basic: _builtins.str = ..., meta: _common_pb2.Metadata | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["basic", b"basic", "meta", b"meta", "namespace", b"namespace"] - def __init__(self, *, basic: _builtins.str=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['basic', b'basic', 'meta', b'meta', 'namespace', b'namespace'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["basic", b"basic", "meta", b"meta", "namespace", b"namespace"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['basic', b'basic', 'meta', b'meta', 'namespace', b'namespace'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_namespace: _TypeAlias = _typing.Literal["basic"] + _WhichOneofArgType_namespace: _TypeAlias = _typing.Literal["namespace", b"namespace"] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_namespace: _TypeAlias = _typing.Literal['basic'] - _WhichOneofArgType_namespace: _TypeAlias = _typing.Literal['namespace', b'namespace'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_namespace) -> _WhichOneofReturnType_namespace | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_namespace) -> _WhichOneofReturnType_namespace | None: - ... Global___Namespace: _TypeAlias = Namespace @_typing.final @@ -63,6 +61,7 @@ class LibraryName(_message.Message): This can be the initial element in a path or reference. """ + DESCRIPTOR: _descriptor.Descriptor NAME_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @@ -70,17 +69,13 @@ class LibraryName(_message.Message): "* Since libraries allow for inheritance, we will often want to say\n this element, defined in *this* particular library.\n\n In those cases we want to be able to specify the relevant library\n by its identifier.\n\n Otherwise we assume it's somehow implicit which library we're\n talking about.\n " @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__(self, *, name: _builtins.str = ..., meta: _common_pb2.Metadata | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def __init__(self, *, name: _builtins.str=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "name", b"name"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'name', b'name'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... -Global___LibraryName: _TypeAlias = LibraryName \ No newline at end of file +Global___LibraryName: _TypeAlias = LibraryName diff --git a/edg/edgir/ref_pb2.py b/edg/edgir/ref_pb2.py index 154cb44fb..ee4f3fd9c 100644 --- a/edg/edgir/ref_pb2.py +++ b/edg/edgir/ref_pb2.py @@ -1,14 +1,19 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import name_pb2 as edgir_dot_name__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0fedgir/ref.proto\x12\tedgir.ref\x1a\x12edgir/common.proto\x1a\x10edgir/name.proto"f\n\tLocalStep\x12-\n\x0ereserved_param\x18\x01 \x01(\x0e2\x13.edgir.ref.ReservedH\x00\x12\x12\n\x08allocate\x18\x02 \x01(\tH\x00\x12\x0e\n\x04name\x18\x03 \x01(\tH\x00B\x06\n\x04step"W\n\tLocalPath\x12#\n\x05steps\x18\x01 \x03(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata"\xa8\x01\n\x0bLibraryPath\x12&\n\x05start\x18\x01 \x01(\x0b2\x17.edgir.name.LibraryName\x12$\n\x05steps\x18\x02 \x03(\x0b2\x15.edgir.name.Namespace\x12$\n\x06target\x18\x03 \x01(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata*r\n\x08Reserved\x12\r\n\tUNDEFINED\x10\x00\x12\x12\n\x0eCONNECTED_LINK\x10\x01\x12\x10\n\x0cIS_CONNECTED\x10(\x12\n\n\x06LENGTH\x10*\x12\x08\n\x04NAME\x10,\x12\x0c\n\x08ELEMENTS\x10-\x12\r\n\tALLOCATED\x10.b\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x0fedgir/ref.proto\x12\tedgir.ref\x1a\x12edgir/common.proto\x1a\x10edgir/name.proto"f\n\tLocalStep\x12-\n\x0ereserved_param\x18\x01 \x01(\x0e2\x13.edgir.ref.ReservedH\x00\x12\x12\n\x08allocate\x18\x02 \x01(\tH\x00\x12\x0e\n\x04name\x18\x03 \x01(\tH\x00B\x06\n\x04step"W\n\tLocalPath\x12#\n\x05steps\x18\x01 \x03(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata"\xa8\x01\n\x0bLibraryPath\x12&\n\x05start\x18\x01 \x01(\x0b2\x17.edgir.name.LibraryName\x12$\n\x05steps\x18\x02 \x03(\x0b2\x15.edgir.name.Namespace\x12$\n\x06target\x18\x03 \x01(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata*r\n\x08Reserved\x12\r\n\tUNDEFINED\x10\x00\x12\x12\n\x0eCONNECTED_LINK\x10\x01\x12\x10\n\x0cIS_CONNECTED\x10(\x12\n\n\x06LENGTH\x10*\x12\x08\n\x04NAME\x10,\x12\x0c\n\x08ELEMENTS\x10-\x12\r\n\tALLOCATED\x10.b\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.ref_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.ref_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _RESERVED._serialized_start = 432 @@ -18,4 +23,4 @@ _LOCALPATH._serialized_start = 172 _LOCALPATH._serialized_end = 259 _LIBRARYPATH._serialized_start = 262 - _LIBRARYPATH._serialized_end = 430 \ No newline at end of file + _LIBRARYPATH._serialized_end = 430 diff --git a/edg/edgir/ref_pb2.pyi b/edg/edgir/ref_pb2.pyi index 4cb753aaf..992c4f924 100644 --- a/edg/edgir/ref_pb2.pyi +++ b/edg/edgir/ref_pb2.pyi @@ -11,6 +11,7 @@ referencing different elements in a designs or libraries. We enforce certain structural properties by having a series of nested 'steps' that determine the next step in a path reference. """ + from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import name_pb2 as _name_pb2 @@ -21,6 +22,7 @@ from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -28,41 +30,42 @@ else: DESCRIPTOR: _descriptor.FileDescriptor class _Reserved: - ValueType = _typing.NewType('ValueType', _builtins.int) + ValueType = _typing.NewType("ValueType", _builtins.int) V: _TypeAlias = ValueType class _ReservedEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[_Reserved.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: _Reserved.ValueType CONNECTED_LINK: _Reserved.ValueType - '* Directions we could move' + "* Directions we could move" IS_CONNECTED: _Reserved.ValueType - '* reserved parameters\n true implies CONNECTED_LINK resolves; not available on PortArray\n ' + "* reserved parameters\n true implies CONNECTED_LINK resolves; not available on PortArray\n " LENGTH: _Reserved.ValueType - ' EXISTS = 41;\n available on PortArray and LinkArray\n ' + " EXISTS = 41;\n available on PortArray and LinkArray\n " NAME: _Reserved.ValueType ELEMENTS: _Reserved.ValueType - 'available on PortArray and LinkArray, returns a list of string of element names' + "available on PortArray and LinkArray, returns a list of string of element names" ALLOCATED: _Reserved.ValueType - 'cannot be used as a generator dependency\n available on PortArray, returns a list of string of incoming connection names,\n ' + "cannot be used as a generator dependency\n available on PortArray, returns a list of string of incoming connection names,\n " class Reserved(_Reserved, metaclass=_ReservedEnumTypeWrapper): """* These are reserved terms that we'll end up using in various places. I'd rather have these in the block/link/bridges where they're going to exist, but that's not possible without polymorphism protibuf doesn't have """ + UNDEFINED: Reserved.ValueType CONNECTED_LINK: Reserved.ValueType -'* Directions we could move' +"* Directions we could move" IS_CONNECTED: Reserved.ValueType -'* reserved parameters\ntrue implies CONNECTED_LINK resolves; not available on PortArray\n' +"* reserved parameters\ntrue implies CONNECTED_LINK resolves; not available on PortArray\n" LENGTH: Reserved.ValueType -' EXISTS = 41;\navailable on PortArray and LinkArray\n' +" EXISTS = 41;\navailable on PortArray and LinkArray\n" NAME: Reserved.ValueType ELEMENTS: Reserved.ValueType -'available on PortArray and LinkArray, returns a list of string of element names' +"available on PortArray and LinkArray, returns a list of string of element names" ALLOCATED: Reserved.ValueType -'cannot be used as a generator dependency\navailable on PortArray, returns a list of string of incoming connection names,\n' +"cannot be used as a generator dependency\navailable on PortArray, returns a list of string of incoming connection names,\n" Global___Reserved: _TypeAlias = Reserved @_typing.final @@ -73,31 +76,39 @@ class LocalStep(_message.Message): The directions encode the type of thing we are referencing, but to the user all of these look just like local variables """ + DESCRIPTOR: _descriptor.Descriptor RESERVED_PARAM_FIELD_NUMBER: _builtins.int ALLOCATE_FIELD_NUMBER: _builtins.int NAME_FIELD_NUMBER: _builtins.int reserved_param: Global___Reserved.ValueType allocate: _builtins.str - 'Allocates a new element in an array, valid for arrays only.\n Empty string means automatically allocated, while a non-empty string is a suggested name.\n ' + "Allocates a new element in an array, valid for arrays only.\n Empty string means automatically allocated, while a non-empty string is a suggested name.\n " name: _builtins.str "*\n A local name is what something is called in the context of its parent,\n whether that parent is a namespace (as in the library) or some other\n element (as in a design or heirarchy block).\n\n localNames should have the following properties:\n\n - First char is a lower case letter\n - All other chars must be letters, numbers, '-', '<', '>'\n - lowerCamelCase is preffered, don't use any symbols in the name\n if possible.\n\n These are style guidelines, literally any string will work.\n " - def __init__(self, *, reserved_param: Global___Reserved.ValueType=..., allocate: _builtins.str=..., name: _builtins.str=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['allocate', b'allocate', 'name', b'name', 'reserved_param', b'reserved_param', 'step', b'step'] + def __init__( + self, + *, + reserved_param: Global___Reserved.ValueType = ..., + allocate: _builtins.str = ..., + name: _builtins.str = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "allocate", b"allocate", "name", b"name", "reserved_param", b"reserved_param", "step", b"step" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['allocate', b'allocate', 'name', b'name', 'reserved_param', b'reserved_param', 'step', b'step'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "allocate", b"allocate", "name", b"name", "reserved_param", b"reserved_param", "step", b"step" + ] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_step: _TypeAlias = _typing.Literal['reserved_param', 'allocate', 'name'] - _WhichOneofArgType_step: _TypeAlias = _typing.Literal['step', b'step'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_step: _TypeAlias = _typing.Literal["reserved_param", "allocate", "name"] + _WhichOneofArgType_step: _TypeAlias = _typing.Literal["step", b"step"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_step) -> _WhichOneofReturnType_step | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_step) -> _WhichOneofReturnType_step | None: - ... Global___LocalStep: _TypeAlias = LocalStep @_typing.final @@ -105,28 +116,25 @@ class LocalPath(_message.Message): """* This is a path from a local context to some other local context. To be used as a reference. """ + DESCRIPTOR: _descriptor.Descriptor STEPS_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @_builtins.property - def steps(self) -> _containers.RepeatedCompositeFieldContainer[Global___LocalStep]: - ... - + def steps(self) -> _containers.RepeatedCompositeFieldContainer[Global___LocalStep]: ... @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, *, steps: _abc.Iterable[Global___LocalStep] | None = ..., meta: _common_pb2.Metadata | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] - def __init__(self, *, steps: _abc.Iterable[Global___LocalStep] | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "steps", b"steps"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'steps', b'steps'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___LocalPath: _TypeAlias = LocalPath @_typing.final @@ -134,6 +142,7 @@ class LibraryPath(_message.Message): """* This is a path to an element within a library from the root of a library. To be used as a way to reference such elements. """ + DESCRIPTOR: _descriptor.Descriptor START_FIELD_NUMBER: _builtins.int STEPS_FIELD_NUMBER: _builtins.int @@ -141,29 +150,28 @@ class LibraryPath(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def start(self) -> _name_pb2.LibraryName: - ... - + def start(self) -> _name_pb2.LibraryName: ... @_builtins.property - def steps(self) -> _containers.RepeatedCompositeFieldContainer[_name_pb2.Namespace]: - ... - + def steps(self) -> _containers.RepeatedCompositeFieldContainer[_name_pb2.Namespace]: ... @_builtins.property - def target(self) -> Global___LocalStep: - ... - + def target(self) -> Global___LocalStep: ... @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... - - def __init__(self, *, start: _name_pb2.LibraryName | None=..., steps: _abc.Iterable[_name_pb2.Namespace] | None=..., target: Global___LocalStep | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'start', b'start', 'target', b'target'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'start', b'start', 'steps', b'steps', 'target', b'target'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... -Global___LibraryPath: _TypeAlias = LibraryPath \ No newline at end of file + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + start: _name_pb2.LibraryName | None = ..., + steps: _abc.Iterable[_name_pb2.Namespace] | None = ..., + target: Global___LocalStep | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "start", b"start", "target", b"target"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "meta", b"meta", "start", b"start", "steps", b"steps", "target", b"target" + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___LibraryPath: _TypeAlias = LibraryPath diff --git a/edg/edgir/schema_pb2.py b/edg/edgir/schema_pb2.py index 46253e26c..515fd4516 100644 --- a/edg/edgir/schema_pb2.py +++ b/edg/edgir/schema_pb2.py @@ -1,18 +1,23 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import elem_pb2 as edgir_dot_elem__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12edgir/schema.proto\x12\x0cedgir.schema\x1a\x12edgir/common.proto\x1a\x10edgir/elem.proto"\xf5\x03\n\x07Library\x12*\n\x02id\x18\x01 \x01(\x0b2\x1e.edgir.schema.Library.LibIdent\x12\x0f\n\x07imports\x18\x02 \x03(\t\x12&\n\x04root\x18\n \x01(\x0b2\x18.edgir.schema.Library.NS\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a\xc4\x02\n\x02NS\x126\n\x07members\x18\x01 \x03(\x0b2%.edgir.schema.Library.NS.MembersEntry\x1a\xb7\x01\n\x03Val\x12 \n\x04port\x18\n \x01(\x0b2\x10.edgir.elem.PortH\x00\x125\n\x0fhierarchy_block\x18\r \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00\x12 \n\x04link\x18\x0e \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12-\n\tnamespace\x18\x14 \x01(\x0b2\x18.edgir.schema.Library.NSH\x00B\x06\n\x04type\x1aL\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12+\n\x05value\x18\x02 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val:\x028\x01\x1a\x18\n\x08LibIdent\x12\x0c\n\x04name\x18\x01 \x01(\t"6\n\x06Design\x12,\n\x08contents\x18\x02 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockb\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x12edgir/schema.proto\x12\x0cedgir.schema\x1a\x12edgir/common.proto\x1a\x10edgir/elem.proto"\xf5\x03\n\x07Library\x12*\n\x02id\x18\x01 \x01(\x0b2\x1e.edgir.schema.Library.LibIdent\x12\x0f\n\x07imports\x18\x02 \x03(\t\x12&\n\x04root\x18\n \x01(\x0b2\x18.edgir.schema.Library.NS\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a\xc4\x02\n\x02NS\x126\n\x07members\x18\x01 \x03(\x0b2%.edgir.schema.Library.NS.MembersEntry\x1a\xb7\x01\n\x03Val\x12 \n\x04port\x18\n \x01(\x0b2\x10.edgir.elem.PortH\x00\x125\n\x0fhierarchy_block\x18\r \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00\x12 \n\x04link\x18\x0e \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12-\n\tnamespace\x18\x14 \x01(\x0b2\x18.edgir.schema.Library.NSH\x00B\x06\n\x04type\x1aL\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12+\n\x05value\x18\x02 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val:\x028\x01\x1a\x18\n\x08LibIdent\x12\x0c\n\x04name\x18\x01 \x01(\t"6\n\x06Design\x12,\n\x08contents\x18\x02 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.schema_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.schema_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _LIBRARY_NS_MEMBERSENTRY._options = None - _LIBRARY_NS_MEMBERSENTRY._serialized_options = b'8\x01' + _LIBRARY_NS_MEMBERSENTRY._serialized_options = b"8\x01" _LIBRARY._serialized_start = 75 _LIBRARY._serialized_end = 576 _LIBRARY_NS._serialized_start = 226 @@ -24,4 +29,4 @@ _LIBRARY_LIBIDENT._serialized_start = 552 _LIBRARY_LIBIDENT._serialized_end = 576 _DESIGN._serialized_start = 578 - _DESIGN._serialized_end = 632 \ No newline at end of file + _DESIGN._serialized_end = 632 diff --git a/edg/edgir/schema_pb2.pyi b/edg/edgir/schema_pb2.pyi index eeb7ebf64..3080870ab 100644 --- a/edg/edgir/schema_pb2.pyi +++ b/edg/edgir/schema_pb2.pyi @@ -8,6 +8,7 @@ Package : edg.schema These types contain the highest level data structures we use to describe sets of blocks, ports, and links. """ + from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import elem_pb2 as _elem_pb2 @@ -17,6 +18,7 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -35,11 +37,13 @@ class Library(_message.Message): or definitional conflicts. This means that we can shuffle around partial libraries, for merging, modification, etc.. """ + DESCRIPTOR: _descriptor.Descriptor @_typing.final class NS(_message.Message): """* Library Namespace, avoiding collision w/ edg.name.Namespace""" + DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -51,36 +55,53 @@ class Library(_message.Message): NAMESPACE_FIELD_NUMBER: _builtins.int @_builtins.property - def port(self) -> _elem_pb2.Port: - ... - + def port(self) -> _elem_pb2.Port: ... @_builtins.property - def hierarchy_block(self) -> _elem_pb2.HierarchyBlock: - ... - + def hierarchy_block(self) -> _elem_pb2.HierarchyBlock: ... @_builtins.property - def link(self) -> _elem_pb2.Link: - ... - + def link(self) -> _elem_pb2.Link: ... @_builtins.property - def namespace(self) -> Global___Library.NS: - ... - - def __init__(self, *, port: _elem_pb2.Port | None=..., hierarchy_block: _elem_pb2.HierarchyBlock | None=..., link: _elem_pb2.Link | None=..., namespace: Global___Library.NS | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['hierarchy_block', b'hierarchy_block', 'link', b'link', 'namespace', b'namespace', 'port', b'port', 'type', b'type'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['hierarchy_block', b'hierarchy_block', 'link', b'link', 'namespace', b'namespace', 'port', b'port', 'type', b'type'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['port', 'hierarchy_block', 'link', 'namespace'] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: - ... + def namespace(self) -> Global___Library.NS: ... + def __init__( + self, + *, + port: _elem_pb2.Port | None = ..., + hierarchy_block: _elem_pb2.HierarchyBlock | None = ..., + link: _elem_pb2.Link | None = ..., + namespace: Global___Library.NS | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "hierarchy_block", + b"hierarchy_block", + "link", + b"link", + "namespace", + b"namespace", + "port", + b"port", + "type", + b"type", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "hierarchy_block", + b"hierarchy_block", + "link", + b"link", + "namespace", + b"namespace", + "port", + b"port", + "type", + b"type", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["port", "hierarchy_block", "link", "namespace"] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... @_typing.final class MembersEntry(_message.Message): @@ -90,83 +111,75 @@ class Library(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___Library.NS.Val: - ... + def value(self) -> Global___Library.NS.Val: ... + def __init__(self, *, key: _builtins.str = ..., value: Global___Library.NS.Val | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] - def __init__(self, *, key: _builtins.str=..., value: Global___Library.NS.Val | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... MEMBERS_FIELD_NUMBER: _builtins.int @_builtins.property - def members(self) -> _containers.MessageMap[_builtins.str, Global___Library.NS.Val]: - ... + def members(self) -> _containers.MessageMap[_builtins.str, Global___Library.NS.Val]: ... + def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___Library.NS.Val] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["members", b"members"] - def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___Library.NS.Val] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['members', b'members'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... @_typing.final class LibIdent(_message.Message): """* How we identify a library within a set. Will probably evolve to capture more metadata. """ + DESCRIPTOR: _descriptor.Descriptor NAME_FIELD_NUMBER: _builtins.int name: _builtins.str - def __init__(self, *, name: _builtins.str=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name'] + def __init__(self, *, name: _builtins.str = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... ID_FIELD_NUMBER: _builtins.int IMPORTS_FIELD_NUMBER: _builtins.int ROOT_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @_builtins.property - def id(self) -> Global___Library.LibIdent: - ... - + def id(self) -> Global___Library.LibIdent: ... @_builtins.property - def imports(self) -> _containers.RepeatedScalarFieldContainer[_builtins.str]: - ... - + def imports(self) -> _containers.RepeatedScalarFieldContainer[_builtins.str]: ... @_builtins.property - def root(self) -> Global___Library.NS: - ... - + def root(self) -> Global___Library.NS: ... @_builtins.property - def meta(self) -> _common_pb2.Metadata: - ... - - def __init__(self, *, id: Global___Library.LibIdent | None=..., imports: _abc.Iterable[_builtins.str] | None=..., root: Global___Library.NS | None=..., meta: _common_pb2.Metadata | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['id', b'id', 'meta', b'meta', 'root', b'root'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['id', b'id', 'imports', b'imports', 'meta', b'meta', 'root', b'root'] + def meta(self) -> _common_pb2.Metadata: ... + def __init__( + self, + *, + id: Global___Library.LibIdent | None = ..., + imports: _abc.Iterable[_builtins.str] | None = ..., + root: Global___Library.NS | None = ..., + meta: _common_pb2.Metadata | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["id", b"id", "meta", b"meta", "root", b"root"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "id", b"id", "imports", b"imports", "meta", b"meta", "root", b"root" + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___Library: _TypeAlias = Library @_typing.final class Design(_message.Message): """* This is a Design for an embedded system at some level of abstraction.""" + DESCRIPTOR: _descriptor.Descriptor CONTENTS_FIELD_NUMBER: _builtins.int @@ -174,14 +187,12 @@ class Design(_message.Message): def contents(self) -> _elem_pb2.HierarchyBlock: """* Delegate the actual contents of the design to a hierarchy block, for which ports are ignored""" - def __init__(self, *, contents: _elem_pb2.HierarchyBlock | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['contents', b'contents'] + def __init__(self, *, contents: _elem_pb2.HierarchyBlock | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["contents", b"contents"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["contents", b"contents"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['contents', b'contents'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... -Global___Design: _TypeAlias = Design \ No newline at end of file +Global___Design: _TypeAlias = Design diff --git a/edg/edgrpc/compiler_pb2.py b/edg/edgrpc/compiler_pb2.py index 235d99647..a72494fbd 100644 --- a/edg/edgrpc/compiler_pb2.py +++ b/edg/edgrpc/compiler_pb2.py @@ -1,16 +1,21 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import schema_pb2 as edgir_dot_schema__pb2 from ..edgir import ref_pb2 as edgir_dot_ref__pb2 from ..edgir import lit_pb2 as edgir_dot_lit__pb2 from ..edgrpc import hdl_pb2 as edgrpc_dot_hdl__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15edgrpc/compiler.proto\x12\x0fedgrpc.compiler\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x0fedgir/lit.proto\x1a\x10edgrpc/hdl.proto"^\n\x0bErrorRecord\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04kind\x18\x02 \x01(\t\x12\x0c\n\x04name\x18\x03 \x01(\t\x12\x0f\n\x07details\x18\x04 \x01(\t"e\n\x0fCompilerRequest\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"\xf2\x01\n\x0eCompilerResult\x12$\n\x06design\x18\x01 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x06errors\x18\x04 \x03(\x0b2\x1c.edgrpc.compiler.ErrorRecord\x12;\n\x0csolvedValues\x18\x02 \x03(\x0b2%.edgrpc.compiler.CompilerResult.Value\x1aO\n\x05Value\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLitb\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x15edgrpc/compiler.proto\x12\x0fedgrpc.compiler\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x0fedgir/lit.proto\x1a\x10edgrpc/hdl.proto"^\n\x0bErrorRecord\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04kind\x18\x02 \x01(\t\x12\x0c\n\x04name\x18\x03 \x01(\t\x12\x0f\n\x07details\x18\x04 \x01(\t"e\n\x0fCompilerRequest\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"\xf2\x01\n\x0eCompilerResult\x12$\n\x06design\x18\x01 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x06errors\x18\x04 \x03(\x0b2\x1c.edgrpc.compiler.ErrorRecord\x12;\n\x0csolvedValues\x18\x02 \x03(\x0b2%.edgrpc.compiler.CompilerResult.Value\x1aO\n\x05Value\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLitb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgrpc.compiler_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgrpc.compiler_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _ERRORRECORD._serialized_start = 114 @@ -20,4 +25,4 @@ _COMPILERRESULT._serialized_start = 314 _COMPILERRESULT._serialized_end = 556 _COMPILERRESULT_VALUE._serialized_start = 477 - _COMPILERRESULT_VALUE._serialized_end = 556 \ No newline at end of file + _COMPILERRESULT_VALUE._serialized_end = 556 diff --git a/edg/edgrpc/compiler_pb2.pyi b/edg/edgrpc/compiler_pb2.pyi index 09f4d7453..88dd418b3 100644 --- a/edg/edgrpc/compiler_pb2.pyi +++ b/edg/edgrpc/compiler_pb2.pyi @@ -6,6 +6,7 @@ Interface to the HDL (eg, library fetch) is not included here. This no longer uses gRPC to avoid complexity of sockets. """ + from collections import abc as _abc from edgir import lit_pb2 as _lit_pb2 from edgir import ref_pb2 as _ref_pb2 @@ -17,6 +18,7 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -31,26 +33,33 @@ class ErrorRecord(_message.Message): NAME_FIELD_NUMBER: _builtins.int DETAILS_FIELD_NUMBER: _builtins.int kind: _builtins.str - 'kind of error, eg failed to generate' + "kind of error, eg failed to generate" name: _builtins.str - 'constraint name / short description' + "constraint name / short description" details: _builtins.str - 'longer description, optional' + "longer description, optional" @_builtins.property def path(self) -> _ref_pb2.LocalPath: """link / block / port, cannot be the constraint""" - def __init__(self, *, path: _ref_pb2.LocalPath | None=..., kind: _builtins.str=..., name: _builtins.str=..., details: _builtins.str=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path'] + def __init__( + self, + *, + path: _ref_pb2.LocalPath | None = ..., + kind: _builtins.str = ..., + name: _builtins.str = ..., + details: _builtins.str = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "details", b"details", "kind", b"kind", "name", b"name", "path", b"path" + ] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['details', b'details', 'kind', b'kind', 'name', b'name', 'path', b'path'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ErrorRecord: _TypeAlias = ErrorRecord @_typing.final @@ -60,23 +69,19 @@ class CompilerRequest(_message.Message): REFINEMENTS_FIELD_NUMBER: _builtins.int @_builtins.property - def design(self) -> _schema_pb2.Design: - ... - + def design(self) -> _schema_pb2.Design: ... @_builtins.property - def refinements(self) -> _hdl_pb2.Refinements: - ... + def refinements(self) -> _hdl_pb2.Refinements: ... + def __init__( + self, *, design: _schema_pb2.Design | None = ..., refinements: _hdl_pb2.Refinements | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["design", b"design", "refinements", b"refinements"] - def __init__(self, *, design: _schema_pb2.Design | None=..., refinements: _hdl_pb2.Refinements | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinements', b'refinements'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["design", b"design", "refinements", b"refinements"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinements', b'refinements'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___CompilerRequest: _TypeAlias = CompilerRequest @_typing.final @@ -90,47 +95,41 @@ class CompilerResult(_message.Message): VALUE_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: - ... - + def path(self) -> _ref_pb2.LocalPath: ... @_builtins.property - def value(self) -> _lit_pb2.ValueLit: - ... + def value(self) -> _lit_pb2.ValueLit: ... + def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., value: _lit_pb2.ValueLit | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] - def __init__(self, *, path: _ref_pb2.LocalPath | None=..., value: _lit_pb2.ValueLit | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... DESIGN_FIELD_NUMBER: _builtins.int ERRORS_FIELD_NUMBER: _builtins.int SOLVEDVALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def design(self) -> _schema_pb2.Design: - ... - + def design(self) -> _schema_pb2.Design: ... @_builtins.property - def errors(self) -> _containers.RepeatedCompositeFieldContainer[Global___ErrorRecord]: - ... - + def errors(self) -> _containers.RepeatedCompositeFieldContainer[Global___ErrorRecord]: ... @_builtins.property - def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___CompilerResult.Value]: - ... - - def __init__(self, *, design: _schema_pb2.Design | None=..., errors: _abc.Iterable[Global___ErrorRecord] | None=..., solvedValues: _abc.Iterable[Global___CompilerResult.Value] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['design', b'design'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'errors', b'errors', 'solvedValues', b'solvedValues'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... -Global___CompilerResult: _TypeAlias = CompilerResult \ No newline at end of file + def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___CompilerResult.Value]: ... + def __init__( + self, + *, + design: _schema_pb2.Design | None = ..., + errors: _abc.Iterable[Global___ErrorRecord] | None = ..., + solvedValues: _abc.Iterable[Global___CompilerResult.Value] | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["design", b"design"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "design", b"design", "errors", b"errors", "solvedValues", b"solvedValues" + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___CompilerResult: _TypeAlias = CompilerResult diff --git a/edg/edgrpc/hdl_pb2.py b/edg/edgrpc/hdl_pb2.py index 499d3c6e4..97b2a4a65 100644 --- a/edg/edgrpc/hdl_pb2.py +++ b/edg/edgrpc/hdl_pb2.py @@ -1,20 +1,25 @@ """Generated protocol buffer code.""" + from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database + _sym_db = _symbol_database.Default() from ..edgir import schema_pb2 as edgir_dot_schema__pb2 from ..edgir import ref_pb2 as edgir_dot_ref__pb2 from ..edgir import elem_pb2 as edgir_dot_elem__pb2 from ..edgir import lit_pb2 as edgir_dot_lit__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgrpc/hdl.proto\x12\nedgrpc.hdl\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x10edgir/elem.proto\x1a\x0fedgir/lit.proto"\xb6\x04\n\x0bRefinements\x124\n\nsubclasses\x18\x01 \x03(\x0b2 .edgrpc.hdl.Refinements.Subclass\x12-\n\x06values\x18\x02 \x03(\x0b2\x1d.edgrpc.hdl.Refinements.Value\x1a\x8e\x01\n\x08Subclass\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12%\n\x03cls\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12+\n\x0breplacement\x18\x03 \x01(\x0b2\x16.edgir.ref.LibraryPathB\x08\n\x06source\x1a\xb0\x02\n\x05Value\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12A\n\tcls_param\x18\x02 \x01(\x0b2,.edgrpc.hdl.Refinements.Value.ClassParamPathH\x00\x12#\n\x04expr\x18\x03 \x01(\x0b2\x13.edgir.lit.ValueLitH\x01\x12%\n\x05param\x18\x04 \x01(\x0b2\x14.edgir.ref.LocalPathH\x01\x1a_\n\x0eClassParamPath\x12#\n\x03cls\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\nparam_path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPathB\x08\n\x06sourceB\x07\n\x05value"\x1a\n\nModuleName\x12\x0c\n\x04name\x18\x01 \x01(\t"8\n\rIndexResponse\x12\'\n\x07indexed\x18\x01 \x03(\x0b2\x16.edgir.ref.LibraryPath"9\n\x0eLibraryRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath"n\n\x0fLibraryResponse\x12-\n\x07element\x18\x01 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"S\n\tExprValue\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"b\n\x10GeneratorRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12%\n\x06values\x18\x04 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"B\n\x11GeneratorResponse\x12-\n\tgenerated\x18\x01 \x01(\x0b2\x1a.edgir.elem.HierarchyBlock"\x97\x01\n\x11RefinementRequest\x12/\n\x0frefinement_pass\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue">\n\x12RefinementResponse\x12(\n\tnewValues\x18\x01 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"\xfc\x01\n\x0eBackendRequest\x12\'\n\x07backend\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue\x12<\n\targuments\x18\x04 \x03(\x0b2).edgrpc.hdl.BackendRequest.ArgumentsEntry\x1a0\n\x0eArgumentsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x028\x01"\x8e\x01\n\x0fBackendResponse\x123\n\x07results\x18\x01 \x03(\x0b2".edgrpc.hdl.BackendResponse.Result\x1aF\n\x06Result\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0e\n\x04text\x18\x02 \x01(\tH\x00B\x08\n\x06result"1\n\rErrorResponse\x12\r\n\x05error\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x02 \x01(\t"\xc8\x02\n\nHdlRequest\x12.\n\x0cindex_module\x18\x01 \x01(\x0b2\x16.edgrpc.hdl.ModuleNameH\x00\x129\n\x13get_library_element\x18\x02 \x01(\x0b2\x1a.edgrpc.hdl.LibraryRequestH\x00\x12;\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1c.edgrpc.hdl.GeneratorRequestH\x00\x127\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1d.edgrpc.hdl.RefinementRequestH\x00\x121\n\x0brun_backend\x18\x04 \x01(\x0b2\x1a.edgrpc.hdl.BackendRequestH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00B\t\n\x07request"\xfd\x02\n\x0bHdlResponse\x121\n\x0cindex_module\x18\x01 \x01(\x0b2\x19.edgrpc.hdl.IndexResponseH\x00\x12:\n\x13get_library_element\x18\x02 \x01(\x0b2\x1b.edgrpc.hdl.LibraryResponseH\x00\x12<\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1d.edgrpc.hdl.GeneratorResponseH\x00\x128\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1e.edgrpc.hdl.RefinementResponseH\x00\x122\n\x0brun_backend\x18\x04 \x01(\x0b2\x1b.edgrpc.hdl.BackendResponseH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00\x12*\n\x05error\x18c \x01(\x0b2\x19.edgrpc.hdl.ErrorResponseH\x00B\n\n\x08responseb\x06proto3') + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b'\n\x10edgrpc/hdl.proto\x12\nedgrpc.hdl\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x10edgir/elem.proto\x1a\x0fedgir/lit.proto"\xb6\x04\n\x0bRefinements\x124\n\nsubclasses\x18\x01 \x03(\x0b2 .edgrpc.hdl.Refinements.Subclass\x12-\n\x06values\x18\x02 \x03(\x0b2\x1d.edgrpc.hdl.Refinements.Value\x1a\x8e\x01\n\x08Subclass\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12%\n\x03cls\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12+\n\x0breplacement\x18\x03 \x01(\x0b2\x16.edgir.ref.LibraryPathB\x08\n\x06source\x1a\xb0\x02\n\x05Value\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12A\n\tcls_param\x18\x02 \x01(\x0b2,.edgrpc.hdl.Refinements.Value.ClassParamPathH\x00\x12#\n\x04expr\x18\x03 \x01(\x0b2\x13.edgir.lit.ValueLitH\x01\x12%\n\x05param\x18\x04 \x01(\x0b2\x14.edgir.ref.LocalPathH\x01\x1a_\n\x0eClassParamPath\x12#\n\x03cls\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\nparam_path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPathB\x08\n\x06sourceB\x07\n\x05value"\x1a\n\nModuleName\x12\x0c\n\x04name\x18\x01 \x01(\t"8\n\rIndexResponse\x12\'\n\x07indexed\x18\x01 \x03(\x0b2\x16.edgir.ref.LibraryPath"9\n\x0eLibraryRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath"n\n\x0fLibraryResponse\x12-\n\x07element\x18\x01 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"S\n\tExprValue\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"b\n\x10GeneratorRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12%\n\x06values\x18\x04 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"B\n\x11GeneratorResponse\x12-\n\tgenerated\x18\x01 \x01(\x0b2\x1a.edgir.elem.HierarchyBlock"\x97\x01\n\x11RefinementRequest\x12/\n\x0frefinement_pass\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue">\n\x12RefinementResponse\x12(\n\tnewValues\x18\x01 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"\xfc\x01\n\x0eBackendRequest\x12\'\n\x07backend\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue\x12<\n\targuments\x18\x04 \x03(\x0b2).edgrpc.hdl.BackendRequest.ArgumentsEntry\x1a0\n\x0eArgumentsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x028\x01"\x8e\x01\n\x0fBackendResponse\x123\n\x07results\x18\x01 \x03(\x0b2".edgrpc.hdl.BackendResponse.Result\x1aF\n\x06Result\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0e\n\x04text\x18\x02 \x01(\tH\x00B\x08\n\x06result"1\n\rErrorResponse\x12\r\n\x05error\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x02 \x01(\t"\xc8\x02\n\nHdlRequest\x12.\n\x0cindex_module\x18\x01 \x01(\x0b2\x16.edgrpc.hdl.ModuleNameH\x00\x129\n\x13get_library_element\x18\x02 \x01(\x0b2\x1a.edgrpc.hdl.LibraryRequestH\x00\x12;\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1c.edgrpc.hdl.GeneratorRequestH\x00\x127\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1d.edgrpc.hdl.RefinementRequestH\x00\x121\n\x0brun_backend\x18\x04 \x01(\x0b2\x1a.edgrpc.hdl.BackendRequestH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00B\t\n\x07request"\xfd\x02\n\x0bHdlResponse\x121\n\x0cindex_module\x18\x01 \x01(\x0b2\x19.edgrpc.hdl.IndexResponseH\x00\x12:\n\x13get_library_element\x18\x02 \x01(\x0b2\x1b.edgrpc.hdl.LibraryResponseH\x00\x12<\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1d.edgrpc.hdl.GeneratorResponseH\x00\x128\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1e.edgrpc.hdl.RefinementResponseH\x00\x122\n\x0brun_backend\x18\x04 \x01(\x0b2\x1b.edgrpc.hdl.BackendResponseH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00\x12*\n\x05error\x18c \x01(\x0b2\x19.edgrpc.hdl.ErrorResponseH\x00B\n\n\x08responseb\x06proto3' +) _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgrpc.hdl_pb2', globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgrpc.hdl_pb2", globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _BACKENDREQUEST_ARGUMENTSENTRY._options = None - _BACKENDREQUEST_ARGUMENTSENTRY._serialized_options = b'8\x01' + _BACKENDREQUEST_ARGUMENTSENTRY._serialized_options = b"8\x01" _REFINEMENTS._serialized_start = 105 _REFINEMENTS._serialized_end = 671 _REFINEMENTS_SUBCLASS._serialized_start = 222 @@ -54,4 +59,4 @@ _HDLREQUEST._serialized_start = 1853 _HDLREQUEST._serialized_end = 2181 _HDLRESPONSE._serialized_start = 2184 - _HDLRESPONSE._serialized_end = 2565 \ No newline at end of file + _HDLRESPONSE._serialized_end = 2565 diff --git a/edg/edgrpc/hdl_pb2.pyi b/edg/edgrpc/hdl_pb2.pyi index 14ede7317..6f22f752f 100644 --- a/edg/edgrpc/hdl_pb2.pyi +++ b/edg/edgrpc/hdl_pb2.pyi @@ -4,6 +4,7 @@ isort:skip_file * Defines messages for a service provided in Python that exposes HDL-to-edgir elaboration for a compiler in a different process / language. """ + from collections import abc as _abc from edgir import elem_pb2 as _elem_pb2 from edgir import lit_pb2 as _lit_pb2 @@ -15,6 +16,7 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing + if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -33,32 +35,32 @@ class Refinements(_message.Message): REPLACEMENT_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: - ... - + def path(self) -> _ref_pb2.LocalPath: ... @_builtins.property - def cls(self) -> _ref_pb2.LibraryPath: - ... - + def cls(self) -> _ref_pb2.LibraryPath: ... @_builtins.property - def replacement(self) -> _ref_pb2.LibraryPath: - ... - - def __init__(self, *, path: _ref_pb2.LocalPath | None=..., cls: _ref_pb2.LibraryPath | None=..., replacement: _ref_pb2.LibraryPath | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'path', b'path', 'replacement', b'replacement', 'source', b'source'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'path', b'path', 'replacement', b'replacement', 'source', b'source'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_source: _TypeAlias = _typing.Literal['path', 'cls'] - _WhichOneofArgType_source: _TypeAlias = _typing.Literal['source', b'source'] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: - ... + def replacement(self) -> _ref_pb2.LibraryPath: ... + def __init__( + self, + *, + path: _ref_pb2.LocalPath | None = ..., + cls: _ref_pb2.LibraryPath | None = ..., + replacement: _ref_pb2.LibraryPath | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "cls", b"cls", "path", b"path", "replacement", b"replacement", "source", b"source" + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "cls", b"cls", "path", b"path", "replacement", b"replacement", "source", b"source" + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_source: _TypeAlias = _typing.Literal["path", "cls"] + _WhichOneofArgType_source: _TypeAlias = _typing.Literal["source", b"source"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: ... @_typing.final class Value(_message.Message): @@ -71,36 +73,28 @@ class Refinements(_message.Message): PARAM_PATH_FIELD_NUMBER: _builtins.int @_builtins.property - def cls(self) -> _ref_pb2.LibraryPath: - ... - + def cls(self) -> _ref_pb2.LibraryPath: ... @_builtins.property - def param_path(self) -> _ref_pb2.LocalPath: - ... + def param_path(self) -> _ref_pb2.LocalPath: ... + def __init__( + self, *, cls: _ref_pb2.LibraryPath | None = ..., param_path: _ref_pb2.LocalPath | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["cls", b"cls", "param_path", b"param_path"] - def __init__(self, *, cls: _ref_pb2.LibraryPath | None=..., param_path: _ref_pb2.LocalPath | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'param_path', b'param_path'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["cls", b"cls", "param_path", b"param_path"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'param_path', b'param_path'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... PATH_FIELD_NUMBER: _builtins.int CLS_PARAM_FIELD_NUMBER: _builtins.int EXPR_FIELD_NUMBER: _builtins.int PARAM_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: - ... - + def path(self) -> _ref_pb2.LocalPath: ... @_builtins.property - def cls_param(self) -> Global___Refinements.Value.ClassParamPath: - ... - + def cls_param(self) -> Global___Refinements.Value.ClassParamPath: ... @_builtins.property def expr(self) -> _lit_pb2.ValueLit: """set to a specific value""" @@ -109,45 +103,73 @@ class Refinements(_message.Message): def param(self) -> _ref_pb2.LocalPath: """set to a value of another parameter - invalid for classes for now""" - def __init__(self, *, path: _ref_pb2.LocalPath | None=..., cls_param: Global___Refinements.Value.ClassParamPath | None=..., expr: _lit_pb2.ValueLit | None=..., param: _ref_pb2.LocalPath | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['cls_param', b'cls_param', 'expr', b'expr', 'param', b'param', 'path', b'path', 'source', b'source', 'value', b'value'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['cls_param', b'cls_param', 'expr', b'expr', 'param', b'param', 'path', b'path', 'source', b'source', 'value', b'value'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_source: _TypeAlias = _typing.Literal['path', 'cls_param'] - _WhichOneofArgType_source: _TypeAlias = _typing.Literal['source', b'source'] - _WhichOneofReturnType_value: _TypeAlias = _typing.Literal['expr', 'param'] - _WhichOneofArgType_value: _TypeAlias = _typing.Literal['value', b'value'] + def __init__( + self, + *, + path: _ref_pb2.LocalPath | None = ..., + cls_param: Global___Refinements.Value.ClassParamPath | None = ..., + expr: _lit_pb2.ValueLit | None = ..., + param: _ref_pb2.LocalPath | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "cls_param", + b"cls_param", + "expr", + b"expr", + "param", + b"param", + "path", + b"path", + "source", + b"source", + "value", + b"value", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "cls_param", + b"cls_param", + "expr", + b"expr", + "param", + b"param", + "path", + b"path", + "source", + b"source", + "value", + b"value", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_source: _TypeAlias = _typing.Literal["path", "cls_param"] + _WhichOneofArgType_source: _TypeAlias = _typing.Literal["source", b"source"] + _WhichOneofReturnType_value: _TypeAlias = _typing.Literal["expr", "param"] + _WhichOneofArgType_value: _TypeAlias = _typing.Literal["value", b"value"] @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: - ... - + def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: ... @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_value) -> _WhichOneofReturnType_value | None: - ... + def WhichOneof(self, oneof_group: _WhichOneofArgType_value) -> _WhichOneofReturnType_value | None: ... + SUBCLASSES_FIELD_NUMBER: _builtins.int VALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def subclasses(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Subclass]: - ... - + def subclasses(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Subclass]: ... @_builtins.property - def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Value]: - ... + def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Value]: ... + def __init__( + self, + *, + subclasses: _abc.Iterable[Global___Refinements.Subclass] | None = ..., + values: _abc.Iterable[Global___Refinements.Value] | None = ..., + ) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["subclasses", b"subclasses", "values", b"values"] - def __init__(self, *, subclasses: _abc.Iterable[Global___Refinements.Subclass] | None=..., values: _abc.Iterable[Global___Refinements.Value] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['subclasses', b'subclasses', 'values', b'values'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___Refinements: _TypeAlias = Refinements @_typing.final @@ -156,12 +178,11 @@ class ModuleName(_message.Message): NAME_FIELD_NUMBER: _builtins.int name: _builtins.str - def __init__(self, *, name: _builtins.str=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name'] + def __init__(self, *, name: _builtins.str = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ModuleName: _TypeAlias = ModuleName @_typing.final @@ -170,15 +191,12 @@ class IndexResponse(_message.Message): INDEXED_FIELD_NUMBER: _builtins.int @_builtins.property - def indexed(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: - ... + def indexed(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: ... + def __init__(self, *, indexed: _abc.Iterable[_ref_pb2.LibraryPath] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["indexed", b"indexed"] - def __init__(self, *, indexed: _abc.Iterable[_ref_pb2.LibraryPath] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['indexed', b'indexed'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___IndexResponse: _TypeAlias = IndexResponse @_typing.final @@ -190,16 +208,14 @@ class LibraryRequest(_message.Message): def element(self) -> _ref_pb2.LibraryPath: """library element asked for""" - def __init__(self, *, element: _ref_pb2.LibraryPath | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['element', b'element'] + def __init__(self, *, element: _ref_pb2.LibraryPath | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["element", b"element"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['element', b'element'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["element", b"element"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___LibraryRequest: _TypeAlias = LibraryRequest @_typing.final @@ -209,23 +225,21 @@ class LibraryResponse(_message.Message): REFINEMENTS_FIELD_NUMBER: _builtins.int @_builtins.property - def element(self) -> _schema_pb2.Library.NS.Val: - ... - + def element(self) -> _schema_pb2.Library.NS.Val: ... @_builtins.property def refinements(self) -> Global___Refinements: """only valid if element is a top-level block""" - def __init__(self, *, element: _schema_pb2.Library.NS.Val | None=..., refinements: Global___Refinements | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['element', b'element', 'refinements', b'refinements'] + def __init__( + self, *, element: _schema_pb2.Library.NS.Val | None = ..., refinements: Global___Refinements | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["element", b"element", "refinements", b"refinements"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["element", b"element", "refinements", b"refinements"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['element', b'element', 'refinements', b'refinements'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___LibraryResponse: _TypeAlias = LibraryResponse @_typing.final @@ -235,23 +249,17 @@ class ExprValue(_message.Message): VALUE_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: - ... - + def path(self) -> _ref_pb2.LocalPath: ... @_builtins.property - def value(self) -> _lit_pb2.ValueLit: - ... + def value(self) -> _lit_pb2.ValueLit: ... + def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., value: _lit_pb2.ValueLit | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] - def __init__(self, *, path: _ref_pb2.LocalPath | None=..., value: _lit_pb2.ValueLit | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ExprValue: _TypeAlias = ExprValue @_typing.final @@ -265,19 +273,17 @@ class GeneratorRequest(_message.Message): """path of library element containing the generator""" @_builtins.property - def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: - ... + def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... + def __init__( + self, *, element: _ref_pb2.LibraryPath | None = ..., values: _abc.Iterable[Global___ExprValue] | None = ... + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["element", b"element"] - def __init__(self, *, element: _ref_pb2.LibraryPath | None=..., values: _abc.Iterable[Global___ExprValue] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['element', b'element'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["element", b"element", "values", b"values"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['element', b'element', 'values', b'values'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___GeneratorRequest: _TypeAlias = GeneratorRequest @_typing.final @@ -286,19 +292,15 @@ class GeneratorResponse(_message.Message): GENERATED_FIELD_NUMBER: _builtins.int @_builtins.property - def generated(self) -> _elem_pb2.HierarchyBlock: - ... + def generated(self) -> _elem_pb2.HierarchyBlock: ... + def __init__(self, *, generated: _elem_pb2.HierarchyBlock | None = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["generated", b"generated"] - def __init__(self, *, generated: _elem_pb2.HierarchyBlock | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['generated', b'generated'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["generated", b"generated"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['generated', b'generated'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___GeneratorResponse: _TypeAlias = GeneratorResponse @_typing.final @@ -306,33 +308,34 @@ class RefinementRequest(_message.Message): """Runs a refinement pass - something that takes a full design and solved values and generates additional values, eg for refdes assignment """ + DESCRIPTOR: _descriptor.Descriptor REFINEMENT_PASS_FIELD_NUMBER: _builtins.int DESIGN_FIELD_NUMBER: _builtins.int SOLVEDVALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def refinement_pass(self) -> _ref_pb2.LibraryPath: - ... - + def refinement_pass(self) -> _ref_pb2.LibraryPath: ... @_builtins.property - def design(self) -> _schema_pb2.Design: - ... - + def design(self) -> _schema_pb2.Design: ... @_builtins.property - def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: - ... - - def __init__(self, *, refinement_pass: _ref_pb2.LibraryPath | None=..., design: _schema_pb2.Design | None=..., solvedValues: _abc.Iterable[Global___ExprValue] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinement_pass', b'refinement_pass'] + def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... + def __init__( + self, + *, + refinement_pass: _ref_pb2.LibraryPath | None = ..., + design: _schema_pb2.Design | None = ..., + solvedValues: _abc.Iterable[Global___ExprValue] | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["design", b"design", "refinement_pass", b"refinement_pass"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "design", b"design", "refinement_pass", b"refinement_pass", "solvedValues", b"solvedValues" + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinement_pass', b'refinement_pass', 'solvedValues', b'solvedValues'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___RefinementRequest: _TypeAlias = RefinementRequest @_typing.final @@ -341,15 +344,12 @@ class RefinementResponse(_message.Message): NEWVALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def newValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: - ... + def newValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... + def __init__(self, *, newValues: _abc.Iterable[Global___ExprValue] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["newValues", b"newValues"] - def __init__(self, *, newValues: _abc.Iterable[Global___ExprValue] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['newValues', b'newValues'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___RefinementResponse: _TypeAlias = RefinementResponse @_typing.final @@ -357,6 +357,7 @@ class BackendRequest(_message.Message): """Runs a backend - something that generates fabrication artifacts from a compiled design tree eg, generate KiCad netlist, or generate microcontroller firmware pinmap headers """ + DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -367,43 +368,41 @@ class BackendRequest(_message.Message): key: _builtins.str value: _builtins.str - def __init__(self, *, key: _builtins.str=..., value: _builtins.str=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def __init__(self, *, key: _builtins.str = ..., value: _builtins.str = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... BACKEND_FIELD_NUMBER: _builtins.int DESIGN_FIELD_NUMBER: _builtins.int SOLVEDVALUES_FIELD_NUMBER: _builtins.int ARGUMENTS_FIELD_NUMBER: _builtins.int @_builtins.property - def backend(self) -> _ref_pb2.LibraryPath: - ... - + def backend(self) -> _ref_pb2.LibraryPath: ... @_builtins.property - def design(self) -> _schema_pb2.Design: - ... - + def design(self) -> _schema_pb2.Design: ... @_builtins.property - def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: - ... - + def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... @_builtins.property - def arguments(self) -> _containers.ScalarMap[_builtins.str, _builtins.str]: - ... - - def __init__(self, *, backend: _ref_pb2.LibraryPath | None=..., design: _schema_pb2.Design | None=..., solvedValues: _abc.Iterable[Global___ExprValue] | None=..., arguments: _abc.Mapping[_builtins.str, _builtins.str] | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['backend', b'backend', 'design', b'design'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['arguments', b'arguments', 'backend', b'backend', 'design', b'design', 'solvedValues', b'solvedValues'] + def arguments(self) -> _containers.ScalarMap[_builtins.str, _builtins.str]: ... + def __init__( + self, + *, + backend: _ref_pb2.LibraryPath | None = ..., + design: _schema_pb2.Design | None = ..., + solvedValues: _abc.Iterable[Global___ExprValue] | None = ..., + arguments: _abc.Mapping[_builtins.str, _builtins.str] | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["backend", b"backend", "design", b"design"] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "arguments", b"arguments", "backend", b"backend", "design", b"design", "solvedValues", b"solvedValues" + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___BackendRequest: _TypeAlias = BackendRequest @_typing.final @@ -416,56 +415,50 @@ class BackendResponse(_message.Message): PATH_FIELD_NUMBER: _builtins.int TEXT_FIELD_NUMBER: _builtins.int text: _builtins.str - 'for now, only text supported, for KiCad netlisting' + "for now, only text supported, for KiCad netlisting" @_builtins.property def path(self) -> _ref_pb2.LocalPath: """path of corresponding element in design tree""" - def __init__(self, *, path: _ref_pb2.LocalPath | None=..., text: _builtins.str=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'result', b'result', 'text', b'text'] + def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., text: _builtins.str = ...) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "result", b"result", "text", b"text"] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'result', b'result', 'text', b'text'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "result", b"result", "text", b"text"] - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_result: _TypeAlias = _typing.Literal['text'] - _WhichOneofArgType_result: _TypeAlias = _typing.Literal['result', b'result'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_result: _TypeAlias = _typing.Literal["text"] + _WhichOneofArgType_result: _TypeAlias = _typing.Literal["result", b"result"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_result) -> _WhichOneofReturnType_result | None: ... - def WhichOneof(self, oneof_group: _WhichOneofArgType_result) -> _WhichOneofReturnType_result | None: - ... RESULTS_FIELD_NUMBER: _builtins.int @_builtins.property - def results(self) -> _containers.RepeatedCompositeFieldContainer[Global___BackendResponse.Result]: - ... + def results(self) -> _containers.RepeatedCompositeFieldContainer[Global___BackendResponse.Result]: ... + def __init__(self, *, results: _abc.Iterable[Global___BackendResponse.Result] | None = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["results", b"results"] - def __init__(self, *, results: _abc.Iterable[Global___BackendResponse.Result] | None=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['results', b'results'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___BackendResponse: _TypeAlias = BackendResponse @_typing.final class ErrorResponse(_message.Message): """catch all error response""" + DESCRIPTOR: _descriptor.Descriptor ERROR_FIELD_NUMBER: _builtins.int TRACEBACK_FIELD_NUMBER: _builtins.int error: _builtins.str traceback: _builtins.str - def __init__(self, *, error: _builtins.str=..., traceback: _builtins.str=...) -> None: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['error', b'error', 'traceback', b'traceback'] + def __init__(self, *, error: _builtins.str = ..., traceback: _builtins.str = ...) -> None: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal["error", b"error", "traceback", b"traceback"] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... Global___ErrorResponse: _TypeAlias = ErrorResponse @_typing.final @@ -478,7 +471,7 @@ class HdlRequest(_message.Message): RUN_BACKEND_FIELD_NUMBER: _builtins.int GET_PROTO_VERSION_FIELD_NUMBER: _builtins.int get_proto_version: _builtins.int - 'no data' + "no data" @_builtins.property def index_module(self) -> Global___ModuleName: @@ -493,28 +486,67 @@ class HdlRequest(_message.Message): """returns the elaborated IR""" @_builtins.property - def run_refinement(self) -> Global___RefinementRequest: - ... - + def run_refinement(self) -> Global___RefinementRequest: ... @_builtins.property - def run_backend(self) -> Global___BackendRequest: - ... - - def __init__(self, *, index_module: Global___ModuleName | None=..., get_library_element: Global___LibraryRequest | None=..., elaborate_generator: Global___GeneratorRequest | None=..., run_refinement: Global___RefinementRequest | None=..., run_backend: Global___BackendRequest | None=..., get_proto_version: _builtins.int=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'request', b'request', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'request', b'request', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] + def run_backend(self) -> Global___BackendRequest: ... + def __init__( + self, + *, + index_module: Global___ModuleName | None = ..., + get_library_element: Global___LibraryRequest | None = ..., + elaborate_generator: Global___GeneratorRequest | None = ..., + run_refinement: Global___RefinementRequest | None = ..., + run_backend: Global___BackendRequest | None = ..., + get_proto_version: _builtins.int = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "elaborate_generator", + b"elaborate_generator", + "get_library_element", + b"get_library_element", + "get_proto_version", + b"get_proto_version", + "index_module", + b"index_module", + "request", + b"request", + "run_backend", + b"run_backend", + "run_refinement", + b"run_refinement", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "elaborate_generator", + b"elaborate_generator", + "get_library_element", + b"get_library_element", + "get_proto_version", + b"get_proto_version", + "index_module", + b"index_module", + "request", + b"request", + "run_backend", + b"run_backend", + "run_refinement", + b"run_refinement", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_request: _TypeAlias = _typing.Literal[ + "index_module", + "get_library_element", + "elaborate_generator", + "run_refinement", + "run_backend", + "get_proto_version", + ] + _WhichOneofArgType_request: _TypeAlias = _typing.Literal["request", b"request"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_request) -> _WhichOneofReturnType_request | None: ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_request: _TypeAlias = _typing.Literal['index_module', 'get_library_element', 'elaborate_generator', 'run_refinement', 'run_backend', 'get_proto_version'] - _WhichOneofArgType_request: _TypeAlias = _typing.Literal['request', b'request'] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_request) -> _WhichOneofReturnType_request | None: - ... Global___HdlRequest: _TypeAlias = HdlRequest @_typing.final @@ -534,38 +566,77 @@ class HdlResponse(_message.Message): """list of contained library elements""" @_builtins.property - def get_library_element(self) -> Global___LibraryResponse: - ... - + def get_library_element(self) -> Global___LibraryResponse: ... @_builtins.property - def elaborate_generator(self) -> Global___GeneratorResponse: - ... - + def elaborate_generator(self) -> Global___GeneratorResponse: ... @_builtins.property - def run_refinement(self) -> Global___RefinementResponse: - ... - + def run_refinement(self) -> Global___RefinementResponse: ... @_builtins.property - def run_backend(self) -> Global___BackendResponse: - ... - + def run_backend(self) -> Global___BackendResponse: ... @_builtins.property - def error(self) -> Global___ErrorResponse: - ... - - def __init__(self, *, index_module: Global___IndexResponse | None=..., get_library_element: Global___LibraryResponse | None=..., elaborate_generator: Global___GeneratorResponse | None=..., run_refinement: Global___RefinementResponse | None=..., run_backend: Global___BackendResponse | None=..., get_proto_version: _builtins.int=..., error: Global___ErrorResponse | None=...) -> None: - ... - _HasFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'error', b'error', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'response', b'response', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: - ... - _ClearFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'error', b'error', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'response', b'response', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: - ... - _WhichOneofReturnType_response: _TypeAlias = _typing.Literal['index_module', 'get_library_element', 'elaborate_generator', 'run_refinement', 'run_backend', 'get_proto_version', 'error'] - _WhichOneofArgType_response: _TypeAlias = _typing.Literal['response', b'response'] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_response) -> _WhichOneofReturnType_response | None: - ... -Global___HdlResponse: _TypeAlias = HdlResponse \ No newline at end of file + def error(self) -> Global___ErrorResponse: ... + def __init__( + self, + *, + index_module: Global___IndexResponse | None = ..., + get_library_element: Global___LibraryResponse | None = ..., + elaborate_generator: Global___GeneratorResponse | None = ..., + run_refinement: Global___RefinementResponse | None = ..., + run_backend: Global___BackendResponse | None = ..., + get_proto_version: _builtins.int = ..., + error: Global___ErrorResponse | None = ..., + ) -> None: ... + _HasFieldArgType: _TypeAlias = _typing.Literal[ + "elaborate_generator", + b"elaborate_generator", + "error", + b"error", + "get_library_element", + b"get_library_element", + "get_proto_version", + b"get_proto_version", + "index_module", + b"index_module", + "response", + b"response", + "run_backend", + b"run_backend", + "run_refinement", + b"run_refinement", + ] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... + _ClearFieldArgType: _TypeAlias = _typing.Literal[ + "elaborate_generator", + b"elaborate_generator", + "error", + b"error", + "get_library_element", + b"get_library_element", + "get_proto_version", + b"get_proto_version", + "index_module", + b"index_module", + "response", + b"response", + "run_backend", + b"run_backend", + "run_refinement", + b"run_refinement", + ] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_response: _TypeAlias = _typing.Literal[ + "index_module", + "get_library_element", + "elaborate_generator", + "run_refinement", + "run_backend", + "get_proto_version", + "error", + ] + _WhichOneofArgType_response: _TypeAlias = _typing.Literal["response", b"response"] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_response) -> _WhichOneofReturnType_response | None: ... + +Global___HdlResponse: _TypeAlias = HdlResponse From a1445839ea2a134f35f8682da585596c6b8f4d4e Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Mon, 30 Mar 2026 00:38:56 -0700 Subject: [PATCH 18/21] cleaning --- edg/electronics_model/VoltagePorts.py | 2 +- edg/parts/PowerConditioning.py | 4 ++-- examples/test_protected_charger.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index f46c6a089..1b52e7271 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -78,7 +78,7 @@ def contents(self) -> None: ) self.require( (~(self.sinks.map_extract(lambda x: x.reverse_voltage_out).elts_equals(RangeExpr.EMPTY))).count() <= 1, - "multiple reverse voltage sinks not allowed", + "multiple reverse voltage sources not allowed", ) self.require( diff --git a/edg/parts/PowerConditioning.py b/edg/parts/PowerConditioning.py index d1aa42872..ed951dbaf 100644 --- a/edg/parts/PowerConditioning.py +++ b/edg/parts/PowerConditioning.py @@ -385,7 +385,7 @@ def __getattr__(self, item: str) -> Any: DeprecationWarning, stacklevel=2, ) - return self.pwr_out + return self.pwr_in else: raise AttributeError( item @@ -454,7 +454,7 @@ def contents(self) -> None: ), "pwr_out": VoltageSource( voltage_out=batt_voltage, - reverse_voltage_limits=RangeExpr.ALL, + reverse_voltage_limits=self.pwr_in.link().reverse_voltage_limits, reverse_current_draw=self.pwr_in.link().reverse_current_drawn, ), "gnd": Ground(), diff --git a/examples/test_protected_charger.py b/examples/test_protected_charger.py index ce290503b..a85ee1990 100644 --- a/examples/test_protected_charger.py +++ b/examples/test_protected_charger.py @@ -30,9 +30,9 @@ def contents(self) -> None: ) as imp: self.tp = self.Block(VoltageTestPoint()).connected(self.batt.pwr) self.pmos = imp.Block(PmosChargerReverseProtection()) + self.connect(self.pmos.pwr_in, self.batt.pwr) (self.charger,), _ = self.chain(self.vusb, imp.Block(Mcp73831(200 * mAmp(tol=0.2))), self.pmos.pwr_out) - self.connect(self.pmos.pwr_in, self.batt.pwr) (self.charge_led,), _ = self.chain(self.Block(IndicatorSinkLed(Led.Yellow)), self.charger.stat) self.connect(self.vusb, self.charge_led.pwr) From debbf3ee6b6252636ec2d5ec8fa772c405419f66 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Mon, 30 Mar 2026 00:41:08 -0700 Subject: [PATCH 19/21] cleaning --- edg/electronics_model/VoltagePorts.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index 1b52e7271..32cbc2d81 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -119,11 +119,12 @@ def __init__(self) -> None: # The outer port's voltage_limits is untouched and should be defined in the port def. # TODO: it's a slightly optimization to handle them here. Should it be done? # TODO: or maybe current_limits / voltage_limits shouldn't be a port, but rather a block property? + # However, revesre_voltage_limit is assigned explicitly since it determines reverse sink support self.inner_link = self.Port( VoltageSource( current_limits=RangeExpr.ALL, voltage_out=RangeExpr(), - reverse_voltage_limits=RangeExpr.ALL, + reverse_voltage_limits=RangeExpr(), reverse_current_draw=RangeExpr(), ) ) @@ -138,6 +139,7 @@ def contents(self) -> None: self.assign(self.outer_port.reverse_current_limits, self.inner_link.link().reverse_current_limits) self.assign(self.inner_link.voltage_out, self.outer_port.link().voltage) + self.assign(self.inner_link.reverse_voltage_limits, self.outer_port.link().reverse_voltage_limits) self.assign(self.inner_link.reverse_current_draw, self.outer_port.link().reverse_current_drawn) From e4eb08195b781bd666339366967192d7738a5503 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Mon, 30 Mar 2026 00:41:22 -0700 Subject: [PATCH 20/21] Update VoltagePorts.py --- edg/electronics_model/VoltagePorts.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/edg/electronics_model/VoltagePorts.py b/edg/electronics_model/VoltagePorts.py index 32cbc2d81..5c6adeaac 100644 --- a/edg/electronics_model/VoltagePorts.py +++ b/edg/electronics_model/VoltagePorts.py @@ -119,7 +119,7 @@ def __init__(self) -> None: # The outer port's voltage_limits is untouched and should be defined in the port def. # TODO: it's a slightly optimization to handle them here. Should it be done? # TODO: or maybe current_limits / voltage_limits shouldn't be a port, but rather a block property? - # However, revesre_voltage_limit is assigned explicitly since it determines reverse sink support + # However, reverse_voltage_limit is assigned explicitly since it determines reverse sink support self.inner_link = self.Port( VoltageSource( current_limits=RangeExpr.ALL, From 8c7a5a6a0861f2c6290fbcaf74bcfa78254768e7 Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Mon, 30 Mar 2026 00:51:41 -0700 Subject: [PATCH 21/21] fix some bugs --- edg/electronics_model/DummyDevice.py | 2 +- edg/parts/PowerConditioning.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/edg/electronics_model/DummyDevice.py b/edg/electronics_model/DummyDevice.py index aa0410940..a02d86a95 100644 --- a/edg/electronics_model/DummyDevice.py +++ b/edg/electronics_model/DummyDevice.py @@ -1,4 +1,4 @@ -from ..electronics_model import abstract_block, InternalBlock +from ..core import abstract_block, InternalBlock @abstract_block diff --git a/edg/parts/PowerConditioning.py b/edg/parts/PowerConditioning.py index ed951dbaf..47c76d3d4 100644 --- a/edg/parts/PowerConditioning.py +++ b/edg/parts/PowerConditioning.py @@ -418,10 +418,10 @@ def contents(self) -> None: self.r1 = self.Block(Resistor(resistance=self.r1_val)) self.r2 = self.Block(Resistor(resistance=self.r2_val)) + # use the maximum voltages and currents accounting for both directions batt_voltage = self.pwr_in.link().voltage.hull(self.pwr_out.link().reverse_voltage) - - # taking the max of the current for the both direction. 0 lower bound batt_current = self.pwr_out.link().current_drawn.hull(self.pwr_in.link().reverse_current_drawn) + power = batt_current * batt_current * self.rds_on r1_current = batt_voltage / self.r1.resistance

-a-4V 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�CeF+B+I{Zc4ybz;+=E{x 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 diff --git a/edg/edgir/common_pb2.py b/edg/edgir/common_pb2.py index a88fe9b8c..01c1565e4 100644 --- a/edg/edgir/common_pb2.py +++ b/edg/edgir/common_pb2.py @@ -1,20 +1,16 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x12edgir/common.proto\x12\x0cedgir.common"\x95\x03\n\x08Metadata\x12&\n\x07unknown\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12\x0f\n\x05known\x18\x02 \x01(\tH\x00\x121\n\x07members\x18e \x01(\x0b2\x1e.edgir.common.Metadata.MembersH\x01\x12\x13\n\ttext_leaf\x18f \x01(\tH\x01\x12\x12\n\x08bin_leaf\x18g \x01(\x0cH\x01\x125\n\x0esource_locator\x18n \x01(\x0b2\x1b.edgir.common.SourceLocatorH\x01\x12$\n\x05error\x18p \x01(\x0b2\x13.edgir.common.ErrorH\x01\x1a\x86\x01\n\x07Members\x126\n\x04node\x18\n \x03(\x0b2(.edgir.common.Metadata.Members.NodeEntry\x1aC\n\tNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b2\x16.edgir.common.Metadata:\x028\x01B\x06\n\x04typeB\x06\n\x04meta"\xc9\x01\n\rSourceLocator\x12\x14\n\x0cfile_package\x18\x01 \x01(\t\x12\x13\n\x0bline_offset\x18\x02 \x01(\x05\x12\x12\n\ncol_offset\x18\x03 \x01(\x05\x12;\n\x0bsource_type\x18\x04 \x01(\x0e2&.edgir.common.SourceLocator.SourceType"<\n\nSourceType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0e\n\nDEFINITION\x10\x01\x12\x11\n\rINSTANTIATION\x10\x02"X\n\x05Error\x12\x0f\n\x07message\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x03 \x01(\t\x12+\n\x06source\x18\x02 \x03(\x0b2\x1b.edgir.common.SourceLocator"\x07\n\x05Emptyb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12edgir/common.proto\x12\x0cedgir.common"\x95\x03\n\x08Metadata\x12&\n\x07unknown\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12\x0f\n\x05known\x18\x02 \x01(\tH\x00\x121\n\x07members\x18e \x01(\x0b2\x1e.edgir.common.Metadata.MembersH\x01\x12\x13\n\ttext_leaf\x18f \x01(\tH\x01\x12\x12\n\x08bin_leaf\x18g \x01(\x0cH\x01\x125\n\x0esource_locator\x18n \x01(\x0b2\x1b.edgir.common.SourceLocatorH\x01\x12$\n\x05error\x18p \x01(\x0b2\x13.edgir.common.ErrorH\x01\x1a\x86\x01\n\x07Members\x126\n\x04node\x18\n \x03(\x0b2(.edgir.common.Metadata.Members.NodeEntry\x1aC\n\tNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b2\x16.edgir.common.Metadata:\x028\x01B\x06\n\x04typeB\x06\n\x04meta"\xc9\x01\n\rSourceLocator\x12\x14\n\x0cfile_package\x18\x01 \x01(\t\x12\x13\n\x0bline_offset\x18\x02 \x01(\x05\x12\x12\n\ncol_offset\x18\x03 \x01(\x05\x12;\n\x0bsource_type\x18\x04 \x01(\x0e2&.edgir.common.SourceLocator.SourceType"<\n\nSourceType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0e\n\nDEFINITION\x10\x01\x12\x11\n\rINSTANTIATION\x10\x02"X\n\x05Error\x12\x0f\n\x07message\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x03 \x01(\t\x12+\n\x06source\x18\x02 \x03(\x0b2\x1b.edgir.common.SourceLocator"\x07\n\x05Emptyb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.common_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.common_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _METADATA_MEMBERS_NODEENTRY._options = None - _METADATA_MEMBERS_NODEENTRY._serialized_options = b"8\x01" + _METADATA_MEMBERS_NODEENTRY._serialized_options = b'8\x01' _METADATA._serialized_start = 37 _METADATA._serialized_end = 442 _METADATA_MEMBERS._serialized_start = 292 @@ -28,4 +24,4 @@ _ERROR._serialized_start = 648 _ERROR._serialized_end = 736 _EMPTY._serialized_start = 738 - _EMPTY._serialized_end = 745 + _EMPTY._serialized_end = 745 \ No newline at end of file diff --git a/edg/edgir/common_pb2.pyi b/edg/edgir/common_pb2.pyi index 4fa8ab79c..bad85ffc9 100644 --- a/edg/edgir/common_pb2.pyi +++ b/edg/edgir/common_pb2.pyi @@ -7,7 +7,6 @@ Package : edg.common This is where we keep shared types that we reuse and don't have a good place for. """ - from collections import abc as _abc from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message @@ -16,7 +15,6 @@ from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -26,7 +24,6 @@ DESCRIPTOR: _descriptor.FileDescriptor @_typing.final class Metadata(_message.Message): """* Arbitrary metadata stored in tree form.""" - DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -41,24 +38,31 @@ class Metadata(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___Metadata: ... - def __init__(self, *, key: _builtins.str = ..., value: Global___Metadata | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> Global___Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] + def __init__(self, *, key: _builtins.str=..., value: Global___Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... NODE_FIELD_NUMBER: _builtins.int @_builtins.property - def node(self) -> _containers.MessageMap[_builtins.str, Global___Metadata]: ... - def __init__(self, *, node: _abc.Mapping[_builtins.str, Global___Metadata] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["node", b"node"] + def node(self) -> _containers.MessageMap[_builtins.str, Global___Metadata]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, node: _abc.Mapping[_builtins.str, Global___Metadata] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['node', b'node'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... UNKNOWN_FIELD_NUMBER: _builtins.int KNOWN_FIELD_NUMBER: _builtins.int MEMBERS_FIELD_NUMBER: _builtins.int @@ -69,12 +73,16 @@ class Metadata(_message.Message): known: _builtins.str text_leaf: _builtins.str bin_leaf: _builtins.bytes - "* I wanted to split binary and text data, since we might\n just want to dump a raw file/image/datasheet in here\n for safekeeping.\n\n Mixing up binary and textual formats is just a recipe\n for trouble.\n " + '* I wanted to split binary and text data, since we might\n just want to dump a raw file/image/datasheet in here\n for safekeeping.\n\n Mixing up binary and textual formats is just a recipe\n for trouble.\n ' @_builtins.property - def unknown(self) -> Global___Empty: ... + def unknown(self) -> Global___Empty: + ... + @_builtins.property - def members(self) -> Global___Metadata.Members: ... + def members(self) -> Global___Metadata.Members: + ... + @_builtins.property def source_locator(self) -> Global___SourceLocator: """Defined formats @@ -83,74 +91,31 @@ class Metadata(_message.Message): """ @_builtins.property - def error(self) -> Global___Error: ... - def __init__( - self, - *, - unknown: Global___Empty | None = ..., - known: _builtins.str = ..., - members: Global___Metadata.Members | None = ..., - text_leaf: _builtins.str = ..., - bin_leaf: _builtins.bytes = ..., - source_locator: Global___SourceLocator | None = ..., - error: Global___Error | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "bin_leaf", - b"bin_leaf", - "error", - b"error", - "known", - b"known", - "members", - b"members", - "meta", - b"meta", - "source_locator", - b"source_locator", - "text_leaf", - b"text_leaf", - "type", - b"type", - "unknown", - b"unknown", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "bin_leaf", - b"bin_leaf", - "error", - b"error", - "known", - b"known", - "members", - b"members", - "meta", - b"meta", - "source_locator", - b"source_locator", - "text_leaf", - b"text_leaf", - "type", - b"type", - "unknown", - b"unknown", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_meta: _TypeAlias = _typing.Literal[ - "members", "text_leaf", "bin_leaf", "source_locator", "error" - ] - _WhichOneofArgType_meta: _TypeAlias = _typing.Literal["meta", b"meta"] - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["unknown", "known"] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] + def error(self) -> Global___Error: + ... + + def __init__(self, *, unknown: Global___Empty | None=..., known: _builtins.str=..., members: Global___Metadata.Members | None=..., text_leaf: _builtins.str=..., bin_leaf: _builtins.bytes=..., source_locator: Global___SourceLocator | None=..., error: Global___Error | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['bin_leaf', b'bin_leaf', 'error', b'error', 'known', b'known', 'members', b'members', 'meta', b'meta', 'source_locator', b'source_locator', 'text_leaf', b'text_leaf', 'type', b'type', 'unknown', b'unknown'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['bin_leaf', b'bin_leaf', 'error', b'error', 'known', b'known', 'members', b'members', 'meta', b'meta', 'source_locator', b'source_locator', 'text_leaf', b'text_leaf', 'type', b'type', 'unknown', b'unknown'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_meta: _TypeAlias = _typing.Literal['members', 'text_leaf', 'bin_leaf', 'source_locator', 'error'] + _WhichOneofArgType_meta: _TypeAlias = _typing.Literal['meta', b'meta'] + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['unknown', 'known'] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_meta) -> _WhichOneofReturnType_meta | None: ... - @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... + def WhichOneof(self, oneof_group: _WhichOneofArgType_meta) -> _WhichOneofReturnType_meta | None: + ... + @_typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: + ... Global___Metadata: _TypeAlias = Metadata @_typing.final @@ -159,62 +124,45 @@ class SourceLocator(_message.Message): * For locating source data """ - DESCRIPTOR: _descriptor.Descriptor class _SourceType: - ValueType = _typing.NewType("ValueType", _builtins.int) + ValueType = _typing.NewType('ValueType', _builtins.int) V: _TypeAlias = ValueType - class _SourceTypeEnumTypeWrapper( - _enum_type_wrapper._EnumTypeWrapper[SourceLocator._SourceType.ValueType], _builtins.type - ): + class _SourceTypeEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[SourceLocator._SourceType.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNKNOWN: SourceLocator._SourceType.ValueType DEFINITION: SourceLocator._SourceType.ValueType - "source defining this class, would be present in library" + 'source defining this class, would be present in library' INSTANTIATION: SourceLocator._SourceType.ValueType - "source of instantiation, would be present in design" + 'source of instantiation, would be present in design' - class SourceType(_SourceType, metaclass=_SourceTypeEnumTypeWrapper): ... + class SourceType(_SourceType, metaclass=_SourceTypeEnumTypeWrapper): + ... UNKNOWN: SourceLocator.SourceType.ValueType DEFINITION: SourceLocator.SourceType.ValueType - "source defining this class, would be present in library" + 'source defining this class, would be present in library' INSTANTIATION: SourceLocator.SourceType.ValueType - "source of instantiation, would be present in design" + 'source of instantiation, would be present in design' FILE_PACKAGE_FIELD_NUMBER: _builtins.int LINE_OFFSET_FIELD_NUMBER: _builtins.int COL_OFFSET_FIELD_NUMBER: _builtins.int SOURCE_TYPE_FIELD_NUMBER: _builtins.int file_package: _builtins.str - "package name (portable, not tied to an absolute path) that locates the file" + 'package name (portable, not tied to an absolute path) that locates the file' line_offset: _builtins.int - "line number" + 'line number' col_offset: _builtins.int - "character offset within the line" + 'character offset within the line' source_type: Global___SourceLocator.SourceType.ValueType - def __init__( - self, - *, - file_package: _builtins.str = ..., - line_offset: _builtins.int = ..., - col_offset: _builtins.int = ..., - source_type: Global___SourceLocator.SourceType.ValueType = ..., - ) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "col_offset", - b"col_offset", - "file_package", - b"file_package", - "line_offset", - b"line_offset", - "source_type", - b"source_type", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, file_package: _builtins.str=..., line_offset: _builtins.int=..., col_offset: _builtins.int=..., source_type: Global___SourceLocator.SourceType.ValueType=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['col_offset', b'col_offset', 'file_package', b'file_package', 'line_offset', b'line_offset', 'source_type', b'source_type'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___SourceLocator: _TypeAlias = SourceLocator @_typing.final @@ -222,41 +170,32 @@ class Error(_message.Message): """* Used to communicate results of analysis / checking passes. Limited to Block and Link objects. """ - DESCRIPTOR: _descriptor.Descriptor MESSAGE_FIELD_NUMBER: _builtins.int TRACEBACK_FIELD_NUMBER: _builtins.int SOURCE_FIELD_NUMBER: _builtins.int message: _builtins.str - "free-form error message" + 'free-form error message' traceback: _builtins.str - "full traceback TODO: should there be a structured stack trace?" + 'full traceback TODO: should there be a structured stack trace?' @_builtins.property def source(self) -> _containers.RepeatedCompositeFieldContainer[Global___SourceLocator]: """source locator, eg line of failing constraint""" - def __init__( - self, - *, - message: _builtins.str = ..., - traceback: _builtins.str = ..., - source: _abc.Iterable[Global___SourceLocator] | None = ..., - ) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "message", b"message", "source", b"source", "traceback", b"traceback" - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, message: _builtins.str=..., traceback: _builtins.str=..., source: _abc.Iterable[Global___SourceLocator] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['message', b'message', 'source', b'source', 'traceback', b'traceback'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___Error: _TypeAlias = Error @_typing.final class Empty(_message.Message): """* Placeholder until I figure out how to import properly""" - DESCRIPTOR: _descriptor.Descriptor - def __init__(self) -> None: ... - -Global___Empty: _TypeAlias = Empty + def __init__(self) -> None: + ... +Global___Empty: _TypeAlias = Empty \ No newline at end of file diff --git a/edg/edgir/elem_pb2.py b/edg/edgir/elem_pb2.py index 5b5633fd0..1848baf86 100644 --- a/edg/edgir/elem_pb2.py +++ b/edg/edgir/elem_pb2.py @@ -1,25 +1,20 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import init_pb2 as edgir_dot_init__pb2 from ..edgir import expr_pb2 as edgir_dot_expr__pb2 from ..edgir import ref_pb2 as edgir_dot_ref__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x10edgir/elem.proto\x12\nedgir.elem\x1a\x12edgir/common.proto\x1a\x10edgir/init.proto\x1a\x10edgir/expr.proto\x1a\x0fedgir/ref.proto"@\n\x0cNamedValInit\x12\x0c\n\x04name\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.init.ValInit"D\n\x0eNamedValueExpr\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"B\n\rNamedPortLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.PortLike"D\n\x0eNamedBlockLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.elem.BlockLike"B\n\rNamedLinkLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.LinkLike"\xbf\x02\n\x04Port\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12/\n\x0bconstraints\x18) \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05ports\x18* \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xca\x01\n\tPortArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x05ports\x18\x0e \x01(\x0b2\x1b.edgir.elem.PortArray.PortsH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a1\n\x05Ports\x12(\n\x05ports\x18( \x03(\x0b2\x19.edgir.elem.NamedPortLikeB\n\n\x08contains"\xb0\x01\n\x08PortLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04port\x18\x03 \x01(\x0b2\x10.edgir.elem.PortH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.PortArrayH\x00B\x04\n\x02is"=\n\tParameter\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04unit\x18\x02 \x01(\t"a\n\x18StringDescriptionElement\x12\x0e\n\x04text\x18\x01 \x01(\tH\x00\x12&\n\x05param\x18\x02 \x01(\x0b2\x15.edgir.elem.ParameterH\x00B\r\n\x0bElementType"\xc4\x06\n\x0eHierarchyBlock\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12E\n\x0eparam_defaults\x18\x0f \x03(\x0b2-.edgir.elem.HierarchyBlock.ParamDefaultsEntry\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\x06blocks\x18* \x03(\x0b2\x1a.edgir.elem.NamedBlockLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18, \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x17 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x14 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12/\n\x0fprerefine_class\x18\x15 \x01(\x0b2\x16.edgir.ref.LibraryPath\x120\n\x10prerefine_mixins\x18\x19 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\tgenerator\x18\x16 \x01(\x0b2\x15.edgir.elem.Generator\x12\x13\n\x0bis_abstract\x18\x1e \x01(\x08\x122\n\x12default_refinement\x18\x1f \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement\x1aK\n\x12ParamDefaultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01":\n\tGenerator\x12-\n\x0frequired_params\x18\x02 \x03(\x0b2\x14.edgir.ref.LocalPath"\\\n\x0cBlockLibrary\x12$\n\x04base\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12&\n\x06mixins\x18\x03 \x03(\x0b2\x16.edgir.ref.LibraryPath"\x9c\x01\n\tBlockLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12,\n\x08lib_elem\x18\x05 \x01(\x0b2\x18.edgir.elem.BlockLibraryH\x00\x12/\n\thierarchy\x18\x04 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00B\x06\n\x04type"\xa4\x03\n\x04Link\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement"\xe2\x01\n\tLinkArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xb2\x01\n\x08LinkLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04link\x18\x03 \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.LinkArrayH\x00B\x06\n\x04typeb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/elem.proto\x12\nedgir.elem\x1a\x12edgir/common.proto\x1a\x10edgir/init.proto\x1a\x10edgir/expr.proto\x1a\x0fedgir/ref.proto"@\n\x0cNamedValInit\x12\x0c\n\x04name\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.init.ValInit"D\n\x0eNamedValueExpr\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"B\n\rNamedPortLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.PortLike"D\n\x0eNamedBlockLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.elem.BlockLike"B\n\rNamedLinkLike\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b2\x14.edgir.elem.LinkLike"\xbf\x02\n\x04Port\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12/\n\x0bconstraints\x18) \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05ports\x18* \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xca\x01\n\tPortArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x05ports\x18\x0e \x01(\x0b2\x1b.edgir.elem.PortArray.PortsH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a1\n\x05Ports\x12(\n\x05ports\x18( \x03(\x0b2\x19.edgir.elem.NamedPortLikeB\n\n\x08contains"\xb0\x01\n\x08PortLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04port\x18\x03 \x01(\x0b2\x10.edgir.elem.PortH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.PortArrayH\x00B\x04\n\x02is"=\n\tParameter\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04unit\x18\x02 \x01(\t"a\n\x18StringDescriptionElement\x12\x0e\n\x04text\x18\x01 \x01(\tH\x00\x12&\n\x05param\x18\x02 \x01(\x0b2\x15.edgir.elem.ParameterH\x00B\r\n\x0bElementType"\xc4\x06\n\x0eHierarchyBlock\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12E\n\x0eparam_defaults\x18\x0f \x03(\x0b2-.edgir.elem.HierarchyBlock.ParamDefaultsEntry\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12*\n\x06blocks\x18* \x03(\x0b2\x1a.edgir.elem.NamedBlockLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18, \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x17 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x14 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12/\n\x0fprerefine_class\x18\x15 \x01(\x0b2\x16.edgir.ref.LibraryPath\x120\n\x10prerefine_mixins\x18\x19 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\tgenerator\x18\x16 \x01(\x0b2\x15.edgir.elem.Generator\x12\x13\n\x0bis_abstract\x18\x1e \x01(\x08\x122\n\x12default_refinement\x18\x1f \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement\x1aK\n\x12ParamDefaultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01":\n\tGenerator\x12-\n\x0frequired_params\x18\x02 \x03(\x0b2\x14.edgir.ref.LocalPath"\\\n\x0cBlockLibrary\x12$\n\x04base\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12&\n\x06mixins\x18\x03 \x03(\x0b2\x16.edgir.ref.LibraryPath"\x9c\x01\n\tBlockLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12,\n\x08lib_elem\x18\x05 \x01(\x0b2\x18.edgir.elem.BlockLibraryH\x00\x12/\n\thierarchy\x18\x04 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00B\x06\n\x04type"\xa4\x03\n\x04Link\x12(\n\x06params\x18( \x03(\x0b2\x18.edgir.elem.NamedValInit\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12,\n\x0csuperclasses\x18\x15 \x03(\x0b2\x16.edgir.ref.LibraryPath\x122\n\x12super_superclasses\x18\x18 \x03(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x129\n\x0bdescription\x18\x01 \x03(\x0b2$.edgir.elem.StringDescriptionElement"\xe2\x01\n\tLinkArray\x12*\n\nself_class\x18\x14 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\x05ports\x18) \x03(\x0b2\x19.edgir.elem.NamedPortLike\x12/\n\x0bconstraints\x18* \x03(\x0b2\x1a.edgir.elem.NamedValueExpr\x12(\n\x05links\x18+ \x03(\x0b2\x19.edgir.elem.NamedLinkLike\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"\xb2\x01\n\x08LinkLike\x12(\n\tundefined\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12*\n\x08lib_elem\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12 \n\x04link\x18\x03 \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12&\n\x05array\x18\x04 \x01(\x0b2\x15.edgir.elem.LinkArrayH\x00B\x06\n\x04typeb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.elem_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.elem_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _HIERARCHYBLOCK_PARAMDEFAULTSENTRY._options = None - _HIERARCHYBLOCK_PARAMDEFAULTSENTRY._serialized_options = b"8\x01" + _HIERARCHYBLOCK_PARAMDEFAULTSENTRY._serialized_options = b'8\x01' _NAMEDVALINIT._serialized_start = 105 _NAMEDVALINIT._serialized_end = 169 _NAMEDVALUEEXPR._serialized_start = 171 @@ -57,4 +52,4 @@ _LINKARRAY._serialized_start = 2891 _LINKARRAY._serialized_end = 3117 _LINKLIKE._serialized_start = 3120 - _LINKLIKE._serialized_end = 3298 + _LINKLIKE._serialized_end = 3298 \ No newline at end of file diff --git a/edg/edgir/elem_pb2.pyi b/edg/edgir/elem_pb2.pyi index 4922395ee..9c09803fc 100644 --- a/edg/edgir/elem_pb2.pyi +++ b/edg/edgir/elem_pb2.pyi @@ -13,7 +13,6 @@ We don't strictly differentiate between library elements and elements within a design within the protobuf. In general, when there is a library element, we """ - from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import expr_pb2 as _expr_pb2 @@ -25,7 +24,6 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -38,22 +36,25 @@ class NamedValInit(_message.Message): are unordered (whereas we want to preserve ordering to preserve design intent through the compiler), we use a sequence of these pairs. """ - DESCRIPTOR: _descriptor.Descriptor NAME_FIELD_NUMBER: _builtins.int VALUE_FIELD_NUMBER: _builtins.int name: _builtins.str @_builtins.property - def value(self) -> _init_pb2.ValInit: ... - def __init__(self, *, name: _builtins.str = ..., value: _init_pb2.ValInit | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> _init_pb2.ValInit: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] + def __init__(self, *, name: _builtins.str=..., value: _init_pb2.ValInit | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___NamedValInit: _TypeAlias = NamedValInit @_typing.final @@ -64,15 +65,19 @@ class NamedValueExpr(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> _expr_pb2.ValueExpr: ... - def __init__(self, *, name: _builtins.str = ..., value: _expr_pb2.ValueExpr | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> _expr_pb2.ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] + def __init__(self, *, name: _builtins.str=..., value: _expr_pb2.ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___NamedValueExpr: _TypeAlias = NamedValueExpr @_typing.final @@ -83,15 +88,19 @@ class NamedPortLike(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> Global___PortLike: ... - def __init__(self, *, name: _builtins.str = ..., value: Global___PortLike | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> Global___PortLike: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] + def __init__(self, *, name: _builtins.str=..., value: Global___PortLike | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___NamedPortLike: _TypeAlias = NamedPortLike @_typing.final @@ -102,15 +111,19 @@ class NamedBlockLike(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> Global___BlockLike: ... - def __init__(self, *, name: _builtins.str = ..., value: Global___BlockLike | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> Global___BlockLike: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] + def __init__(self, *, name: _builtins.str=..., value: Global___BlockLike | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___NamedBlockLike: _TypeAlias = NamedBlockLike @_typing.final @@ -121,15 +134,19 @@ class NamedLinkLike(_message.Message): name: _builtins.str @_builtins.property - def value(self) -> Global___LinkLike: ... - def __init__(self, *, name: _builtins.str = ..., value: Global___LinkLike | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> Global___LinkLike: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name", "value", b"value"] + def __init__(self, *, name: _builtins.str=..., value: Global___LinkLike | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___NamedLinkLike: _TypeAlias = NamedLinkLike @_typing.final @@ -144,13 +161,21 @@ class Port(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: ... + def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: + ... + @_builtins.property - def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: ... + def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: + ... + @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: + ... + @_builtins.property - def self_class(self) -> _ref_pb2.LibraryPath: ... + def self_class(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property def superclasses(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: """superclasses, may be empty""" @@ -163,39 +188,16 @@ class Port(_message.Message): def meta(self) -> _common_pb2.Metadata: """TODO: this provides type hierarchy data only, inheritance semantics are currently undefined""" - def __init__( - self, - *, - params: _abc.Iterable[Global___NamedValInit] | None = ..., - constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., - ports: _abc.Iterable[Global___NamedPortLike] | None = ..., - self_class: _ref_pb2.LibraryPath | None = ..., - superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., - super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "self_class", b"self_class"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "constraints", - b"constraints", - "meta", - b"meta", - "params", - b"params", - "ports", - b"ports", - "self_class", - b"self_class", - "super_superclasses", - b"super_superclasses", - "superclasses", - b"superclasses", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, params: _abc.Iterable[Global___NamedValInit] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., self_class: _ref_pb2.LibraryPath | None=..., superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'self_class', b'self_class'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['constraints', b'constraints', 'meta', b'meta', 'params', b'params', 'ports', b'ports', 'self_class', b'self_class', 'super_superclasses', b'super_superclasses', 'superclasses', b'superclasses'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___Port: _TypeAlias = Port @_typing.final @@ -208,12 +210,15 @@ class PortArray(_message.Message): PORTS_FIELD_NUMBER: _builtins.int @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... - def __init__(self, *, ports: _abc.Iterable[Global___NamedPortLike] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["ports", b"ports"] + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, ports: _abc.Iterable[Global___NamedPortLike] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['ports', b'ports'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... SELF_CLASS_FIELD_NUMBER: _builtins.int PORTS_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @@ -225,37 +230,33 @@ class PortArray(_message.Message): """ @_builtins.property - def ports(self) -> Global___PortArray.Ports: ... + def ports(self) -> Global___PortArray.Ports: + ... + @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - self_class: _ref_pb2.LibraryPath | None = ..., - ports: Global___PortArray.Ports | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "contains", b"contains", "meta", b"meta", "ports", b"ports", "self_class", b"self_class" - ] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "contains", b"contains", "meta", b"meta", "ports", b"ports", "self_class", b"self_class" - ] + def __init__(self, *, self_class: _ref_pb2.LibraryPath | None=..., ports: Global___PortArray.Ports | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['contains', b'contains', 'meta', b'meta', 'ports', b'ports', 'self_class', b'self_class'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_contains: _TypeAlias = _typing.Literal["ports"] - _WhichOneofArgType_contains: _TypeAlias = _typing.Literal["contains", b"contains"] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['contains', b'contains', 'meta', b'meta', 'ports', b'ports', 'self_class', b'self_class'] - def WhichOneof(self, oneof_group: _WhichOneofArgType_contains) -> _WhichOneofReturnType_contains | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_contains: _TypeAlias = _typing.Literal['ports'] + _WhichOneofArgType_contains: _TypeAlias = _typing.Literal['contains', b'contains'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_contains) -> _WhichOneofReturnType_contains | None: + ... Global___PortArray: _TypeAlias = PortArray @_typing.final class PortLike(_message.Message): """* Wrapper for different port like elements""" - DESCRIPTOR: _descriptor.Descriptor UNDEFINED_FIELD_NUMBER: _builtins.int LIB_ELEM_FIELD_NUMBER: _builtins.int @@ -263,38 +264,36 @@ class PortLike(_message.Message): ARRAY_FIELD_NUMBER: _builtins.int @_builtins.property - def undefined(self) -> _common_pb2.Empty: ... + def undefined(self) -> _common_pb2.Empty: + ... + @_builtins.property - def lib_elem(self) -> _ref_pb2.LibraryPath: ... + def lib_elem(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property def port(self) -> Global___Port: """* 'port' disallowed w/in the library""" @_builtins.property - def array(self) -> Global___PortArray: ... - def __init__( - self, - *, - undefined: _common_pb2.Empty | None = ..., - lib_elem: _ref_pb2.LibraryPath | None = ..., - port: Global___Port | None = ..., - array: Global___PortArray | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "array", b"array", "is", b"is", "lib_elem", b"lib_elem", "port", b"port", "undefined", b"undefined" - ] + def array(self) -> Global___PortArray: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "array", b"array", "is", b"is", "lib_elem", b"lib_elem", "port", b"port", "undefined", b"undefined" - ] + def __init__(self, *, undefined: _common_pb2.Empty | None=..., lib_elem: _ref_pb2.LibraryPath | None=..., port: Global___Port | None=..., array: Global___PortArray | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'is', b'is', 'lib_elem', b'lib_elem', 'port', b'port', 'undefined', b'undefined'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_is: _TypeAlias = _typing.Literal["undefined", "lib_elem", "port", "array"] - _WhichOneofArgType_is: _TypeAlias = _typing.Literal["is", b"is"] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'is', b'is', 'lib_elem', b'lib_elem', 'port', b'port', 'undefined', b'undefined'] - def WhichOneof(self, oneof_group: _WhichOneofArgType_is) -> _WhichOneofReturnType_is | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_is: _TypeAlias = _typing.Literal['undefined', 'lib_elem', 'port', 'array'] + _WhichOneofArgType_is: _TypeAlias = _typing.Literal['is', b'is'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_is) -> _WhichOneofReturnType_is | None: + ... Global___PortLike: _TypeAlias = PortLike @_typing.final @@ -305,15 +304,19 @@ class Parameter(_message.Message): unit: _builtins.str @_builtins.property - def path(self) -> _ref_pb2.LocalPath: ... - def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., unit: _builtins.str = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path"] + def path(self) -> _ref_pb2.LocalPath: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "unit", b"unit"] + def __init__(self, *, path: _ref_pb2.LocalPath | None=..., unit: _builtins.str=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'unit', b'unit'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___Parameter: _TypeAlias = Parameter @_typing.final @@ -324,19 +327,24 @@ class StringDescriptionElement(_message.Message): text: _builtins.str @_builtins.property - def param(self) -> Global___Parameter: ... - def __init__(self, *, text: _builtins.str = ..., param: Global___Parameter | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["ElementType", b"ElementType", "param", b"param", "text", b"text"] + def param(self) -> Global___Parameter: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["ElementType", b"ElementType", "param", b"param", "text", b"text"] + def __init__(self, *, text: _builtins.str=..., param: Global___Parameter | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['ElementType', b'ElementType', 'param', b'param', 'text', b'text'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_ElementType: _TypeAlias = _typing.Literal["text", "param"] - _WhichOneofArgType_ElementType: _TypeAlias = _typing.Literal["ElementType", b"ElementType"] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['ElementType', b'ElementType', 'param', b'param', 'text', b'text'] - def WhichOneof(self, oneof_group: _WhichOneofArgType_ElementType) -> _WhichOneofReturnType_ElementType | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_ElementType: _TypeAlias = _typing.Literal['text', 'param'] + _WhichOneofArgType_ElementType: _TypeAlias = _typing.Literal['ElementType', b'ElementType'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_ElementType) -> _WhichOneofReturnType_ElementType | None: + ... Global___StringDescriptionElement: _TypeAlias = StringDescriptionElement @_typing.final @@ -351,15 +359,19 @@ class HierarchyBlock(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> _expr_pb2.ValueExpr: ... - def __init__(self, *, key: _builtins.str = ..., value: _expr_pb2.ValueExpr | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> _expr_pb2.ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] + def __init__(self, *, key: _builtins.str=..., value: _expr_pb2.ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... PARAMS_FIELD_NUMBER: _builtins.int PARAM_DEFAULTS_FIELD_NUMBER: _builtins.int PORTS_FIELD_NUMBER: _builtins.int @@ -377,10 +389,12 @@ class HierarchyBlock(_message.Message): META_FIELD_NUMBER: _builtins.int DESCRIPTION_FIELD_NUMBER: _builtins.int is_abstract: _builtins.bool - "true if self_class is abstract, and should error if used in a design" + 'true if self_class is abstract, and should error if used in a design' @_builtins.property - def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: ... + def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: + ... + @_builtins.property def param_defaults(self) -> _containers.MessageMap[_builtins.str, _expr_pb2.ValueExpr]: """Refinements may introduce new parameters which would not be assigned a value in the parent class. @@ -389,7 +403,9 @@ class HierarchyBlock(_message.Message): """ @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: + ... + @_builtins.property def blocks(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedBlockLike]: """* Bridges, which adapt an edge port to a link port - eg, edge VoltageSink to an internal link @@ -398,7 +414,9 @@ class HierarchyBlock(_message.Message): """ @_builtins.property - def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: ... + def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: + ... + @_builtins.property def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: """* Connections between internal block and link ports are represented by connected constraints. @@ -434,80 +452,23 @@ class HierarchyBlock(_message.Message): """optional default refinement subclass, only valid for library blocks""" @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - @_builtins.property - def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: ... - def __init__( - self, - *, - params: _abc.Iterable[Global___NamedValInit] | None = ..., - param_defaults: _abc.Mapping[_builtins.str, _expr_pb2.ValueExpr] | None = ..., - ports: _abc.Iterable[Global___NamedPortLike] | None = ..., - blocks: _abc.Iterable[Global___NamedBlockLike] | None = ..., - links: _abc.Iterable[Global___NamedLinkLike] | None = ..., - constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., - self_class: _ref_pb2.LibraryPath | None = ..., - superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., - super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., - prerefine_class: _ref_pb2.LibraryPath | None = ..., - prerefine_mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., - generator: Global___Generator | None = ..., - is_abstract: _builtins.bool = ..., - default_refinement: _ref_pb2.LibraryPath | None = ..., - meta: _common_pb2.Metadata | None = ..., - description: _abc.Iterable[Global___StringDescriptionElement] | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "default_refinement", - b"default_refinement", - "generator", - b"generator", - "meta", - b"meta", - "prerefine_class", - b"prerefine_class", - "self_class", - b"self_class", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "blocks", - b"blocks", - "constraints", - b"constraints", - "default_refinement", - b"default_refinement", - "description", - b"description", - "generator", - b"generator", - "is_abstract", - b"is_abstract", - "links", - b"links", - "meta", - b"meta", - "param_defaults", - b"param_defaults", - "params", - b"params", - "ports", - b"ports", - "prerefine_class", - b"prerefine_class", - "prerefine_mixins", - b"prerefine_mixins", - "self_class", - b"self_class", - "super_superclasses", - b"super_superclasses", - "superclasses", - b"superclasses", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def meta(self) -> _common_pb2.Metadata: + ... + + @_builtins.property + def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: + ... + + def __init__(self, *, params: _abc.Iterable[Global___NamedValInit] | None=..., param_defaults: _abc.Mapping[_builtins.str, _expr_pb2.ValueExpr] | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., blocks: _abc.Iterable[Global___NamedBlockLike] | None=..., links: _abc.Iterable[Global___NamedLinkLike] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., self_class: _ref_pb2.LibraryPath | None=..., superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., prerefine_class: _ref_pb2.LibraryPath | None=..., prerefine_mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., generator: Global___Generator | None=..., is_abstract: _builtins.bool=..., default_refinement: _ref_pb2.LibraryPath | None=..., meta: _common_pb2.Metadata | None=..., description: _abc.Iterable[Global___StringDescriptionElement] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['default_refinement', b'default_refinement', 'generator', b'generator', 'meta', b'meta', 'prerefine_class', b'prerefine_class', 'self_class', b'self_class'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['blocks', b'blocks', 'constraints', b'constraints', 'default_refinement', b'default_refinement', 'description', b'description', 'generator', b'generator', 'is_abstract', b'is_abstract', 'links', b'links', 'meta', b'meta', 'param_defaults', b'param_defaults', 'params', b'params', 'ports', b'ports', 'prerefine_class', b'prerefine_class', 'prerefine_mixins', b'prerefine_mixins', 'self_class', b'self_class', 'super_superclasses', b'super_superclasses', 'superclasses', b'superclasses'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___HierarchyBlock: _TypeAlias = HierarchyBlock @_typing.final @@ -521,11 +482,12 @@ class Generator(_message.Message): These parameters are the only ones accessible to the generator. """ - def __init__(self, *, required_params: _abc.Iterable[_ref_pb2.LocalPath] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["required_params", b"required_params"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, required_params: _abc.Iterable[_ref_pb2.LocalPath] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['required_params', b'required_params'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___Generator: _TypeAlias = Generator @_typing.final @@ -535,19 +497,23 @@ class BlockLibrary(_message.Message): MIXINS_FIELD_NUMBER: _builtins.int @_builtins.property - def base(self) -> _ref_pb2.LibraryPath: ... + def base(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property - def mixins(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: ... - def __init__( - self, *, base: _ref_pb2.LibraryPath | None = ..., mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["base", b"base"] + def mixins(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["base", b"base", "mixins", b"mixins"] + def __init__(self, *, base: _ref_pb2.LibraryPath | None=..., mixins: _abc.Iterable[_ref_pb2.LibraryPath] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['base', b'base'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['base', b'base', 'mixins', b'mixins'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___BlockLibrary: _TypeAlias = BlockLibrary @_typing.final @@ -558,35 +524,32 @@ class BlockLike(_message.Message): HIERARCHY_FIELD_NUMBER: _builtins.int @_builtins.property - def undefined(self) -> _common_pb2.Empty: ... + def undefined(self) -> _common_pb2.Empty: + ... + @_builtins.property - def lib_elem(self) -> Global___BlockLibrary: ... + def lib_elem(self) -> Global___BlockLibrary: + ... + @_builtins.property def hierarchy(self) -> Global___HierarchyBlock: """* not allowed w/in the library""" - def __init__( - self, - *, - undefined: _common_pb2.Empty | None = ..., - lib_elem: Global___BlockLibrary | None = ..., - hierarchy: Global___HierarchyBlock | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "hierarchy", b"hierarchy", "lib_elem", b"lib_elem", "type", b"type", "undefined", b"undefined" - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "hierarchy", b"hierarchy", "lib_elem", b"lib_elem", "type", b"type", "undefined", b"undefined" - ] + def __init__(self, *, undefined: _common_pb2.Empty | None=..., lib_elem: Global___BlockLibrary | None=..., hierarchy: Global___HierarchyBlock | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['hierarchy', b'hierarchy', 'lib_elem', b'lib_elem', 'type', b'type', 'undefined', b'undefined'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["undefined", "lib_elem", "hierarchy"] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['hierarchy', b'hierarchy', 'lib_elem', b'lib_elem', 'type', b'type', 'undefined', b'undefined'] - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['undefined', 'lib_elem', 'hierarchy'] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: + ... Global___BlockLike: _TypeAlias = BlockLike @_typing.final @@ -603,15 +566,25 @@ class Link(_message.Message): DESCRIPTION_FIELD_NUMBER: _builtins.int @_builtins.property - def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: ... + def params(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValInit]: + ... + @_builtins.property - def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: ... + def ports(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedPortLike]: + ... + @_builtins.property - def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: ... + def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: + ... + @_builtins.property - def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: ... + def constraints(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedValueExpr]: + ... + @_builtins.property - def self_class(self) -> _ref_pb2.LibraryPath: ... + def self_class(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property def superclasses(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: """superclasses, may be empty""" @@ -625,46 +598,19 @@ class Link(_message.Message): """TODO: this provides type hierarchy data only, inheritance semantics are currently undefined""" @_builtins.property - def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: ... - def __init__( - self, - *, - params: _abc.Iterable[Global___NamedValInit] | None = ..., - ports: _abc.Iterable[Global___NamedPortLike] | None = ..., - links: _abc.Iterable[Global___NamedLinkLike] | None = ..., - constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., - self_class: _ref_pb2.LibraryPath | None = ..., - superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., - super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None = ..., - meta: _common_pb2.Metadata | None = ..., - description: _abc.Iterable[Global___StringDescriptionElement] | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "self_class", b"self_class"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "constraints", - b"constraints", - "description", - b"description", - "links", - b"links", - "meta", - b"meta", - "params", - b"params", - "ports", - b"ports", - "self_class", - b"self_class", - "super_superclasses", - b"super_superclasses", - "superclasses", - b"superclasses", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def description(self) -> _containers.RepeatedCompositeFieldContainer[Global___StringDescriptionElement]: + ... + + def __init__(self, *, params: _abc.Iterable[Global___NamedValInit] | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., links: _abc.Iterable[Global___NamedLinkLike] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., self_class: _ref_pb2.LibraryPath | None=..., superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., super_superclasses: _abc.Iterable[_ref_pb2.LibraryPath] | None=..., meta: _common_pb2.Metadata | None=..., description: _abc.Iterable[Global___StringDescriptionElement] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'self_class', b'self_class'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['constraints', b'constraints', 'description', b'description', 'links', b'links', 'meta', b'meta', 'params', b'params', 'ports', b'ports', 'self_class', b'self_class', 'super_superclasses', b'super_superclasses', 'superclasses', b'superclasses'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___Link: _TypeAlias = Link @_typing.final @@ -693,36 +639,23 @@ class LinkArray(_message.Message): """includes all exported constraints to map link ports to my ports""" @_builtins.property - def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: ... - @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - self_class: _ref_pb2.LibraryPath | None = ..., - ports: _abc.Iterable[Global___NamedPortLike] | None = ..., - constraints: _abc.Iterable[Global___NamedValueExpr] | None = ..., - links: _abc.Iterable[Global___NamedLinkLike] | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "self_class", b"self_class"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "constraints", - b"constraints", - "links", - b"links", - "meta", - b"meta", - "ports", - b"ports", - "self_class", - b"self_class", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def links(self) -> _containers.RepeatedCompositeFieldContainer[Global___NamedLinkLike]: + ... + @_builtins.property + def meta(self) -> _common_pb2.Metadata: + ... + + def __init__(self, *, self_class: _ref_pb2.LibraryPath | None=..., ports: _abc.Iterable[Global___NamedPortLike] | None=..., constraints: _abc.Iterable[Global___NamedValueExpr] | None=..., links: _abc.Iterable[Global___NamedLinkLike] | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'self_class', b'self_class'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['constraints', b'constraints', 'links', b'links', 'meta', b'meta', 'ports', b'ports', 'self_class', b'self_class'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___LinkArray: _TypeAlias = LinkArray @_typing.final @@ -734,36 +667,34 @@ class LinkLike(_message.Message): ARRAY_FIELD_NUMBER: _builtins.int @_builtins.property - def undefined(self) -> _common_pb2.Empty: ... + def undefined(self) -> _common_pb2.Empty: + ... + @_builtins.property - def lib_elem(self) -> _ref_pb2.LibraryPath: ... + def lib_elem(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property def link(self) -> Global___Link: """* not allowed w/in the library""" @_builtins.property - def array(self) -> Global___LinkArray: ... - def __init__( - self, - *, - undefined: _common_pb2.Empty | None = ..., - lib_elem: _ref_pb2.LibraryPath | None = ..., - link: Global___Link | None = ..., - array: Global___LinkArray | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "array", b"array", "lib_elem", b"lib_elem", "link", b"link", "type", b"type", "undefined", b"undefined" - ] + def array(self) -> Global___LinkArray: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "array", b"array", "lib_elem", b"lib_elem", "link", b"link", "type", b"type", "undefined", b"undefined" - ] + def __init__(self, *, undefined: _common_pb2.Empty | None=..., lib_elem: _ref_pb2.LibraryPath | None=..., link: Global___Link | None=..., array: Global___LinkArray | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'lib_elem', b'lib_elem', 'link', b'link', 'type', b'type', 'undefined', b'undefined'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["undefined", "lib_elem", "link", "array"] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'lib_elem', b'lib_elem', 'link', b'link', 'type', b'type', 'undefined', b'undefined'] - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['undefined', 'lib_elem', 'link', 'array'] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] -Global___LinkLike: _TypeAlias = LinkLike + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: + ... +Global___LinkLike: _TypeAlias = LinkLike \ No newline at end of file diff --git a/edg/edgir/expr_pb2.py b/edg/edgir/expr_pb2.py index 6b0f7950b..db1910d84 100644 --- a/edg/edgir/expr_pb2.py +++ b/edg/edgir/expr_pb2.py @@ -1,24 +1,19 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import ref_pb2 as edgir_dot_ref__pb2 from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import lit_pb2 as edgir_dot_lit__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x10edgir/expr.proto\x12\nedgir.expr\x1a\x0fedgir/ref.proto\x1a\x12edgir/common.proto\x1a\x0fedgir/lit.proto"\xb4\x01\n\tUnaryExpr\x12$\n\x02op\x18\x01 \x01(\x0e2\x18.edgir.expr.UnaryExpr.Op\x12"\n\x03val\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"]\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\n\n\x06NEGATE\x10\x01\x12\x07\n\x03NOT\x10\x02\x12\n\n\x06INVERT\x10\x03\x12\x07\n\x03MIN\x10\x04\x12\x07\n\x03MAX\x10\x05\x12\n\n\x06CENTER\x10\x06\x12\t\n\x05WIDTH\x10\x07"\x9f\x02\n\x0cUnarySetExpr\x12\'\n\x02op\x18\x01 \x01(\x0e2\x1b.edgir.expr.UnarySetExpr.Op\x12#\n\x04vals\x18\x04 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xc0\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03SUM\x10\x01\x12\x0c\n\x08ALL_TRUE\x10\x02\x12\x0c\n\x08ANY_TRUE\x10\x03\x12\n\n\x06ALL_EQ\x10\x04\x12\x0e\n\nALL_UNIQUE\x10\x05\x12\x0b\n\x07MAXIMUM\x10\n\x12\x0b\n\x07MINIMUM\x10\x0b\x12\x0f\n\x0bSET_EXTRACT\x10\x0c\x12\x10\n\x0cINTERSECTION\x10\r\x12\x08\n\x04HULL\x10\x0e\x12\n\n\x06NEGATE\x10\x14\x12\n\n\x06INVERT\x10\x15\x12\x0b\n\x07FLATTEN\x10\x1e"\xd4\x02\n\nBinaryExpr\x12%\n\x02op\x18\x01 \x01(\x0e2\x19.edgir.expr.BinaryExpr.Op\x12"\n\x03lhs\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xd6\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\x0f\n\x0bSHRINK_MULT\x107\x12\x07\n\x03AND\x10\x14\x12\x06\n\x02OR\x10\x15\x12\x07\n\x03XOR\x10\x16\x12\x0b\n\x07IMPLIES\x10\x17\x12\x06\n\x02EQ\x10\x1e\x12\x07\n\x03NEQ\x10\x1f\x12\x06\n\x02GT\x10(\x12\x07\n\x03GTE\x10)\x12\x06\n\x02LT\x10*\x12\x07\n\x03LTE\x10,\x12\x07\n\x03MAX\x10-\x12\x07\n\x03MIN\x10.\x12\x10\n\x0cINTERSECTION\x103\x12\x08\n\x04HULL\x106\x12\n\n\x06WITHIN\x105\x12\t\n\x05RANGE\x10\x01"\xb7\x01\n\rBinarySetExpr\x12(\n\x02op\x18\x01 \x01(\x0e2\x1c.edgir.expr.BinarySetExpr.Op\x12$\n\x05lhset\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr"2\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\n\n\x06CONCAT\x10\x14"0\n\tArrayExpr\x12#\n\x04vals\x18\x01 \x03(\x0b2\x15.edgir.expr.ValueExpr"[\n\tRangeExpr\x12&\n\x07minimum\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12&\n\x07maximum\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x80\x01\n\nStructExpr\x12.\n\x04vals\x18\x01 \x03(\x0b2 .edgir.expr.StructExpr.ValsEntry\x1aB\n\tValsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01"\xa3\x01\n\x0eIfThenElseExpr\x12#\n\x04cond\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03tru\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03fal\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"]\n\x0bExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x05index\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"^\n\x0eMapExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x04path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPath"\x91\x01\n\rConnectedExpr\x12)\n\nblock_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12(\n\tlink_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12+\n\x08expanded\x18\x03 \x03(\x0b2\x19.edgir.expr.ConnectedExpr"\x9c\x01\n\x0cExportedExpr\x12,\n\rexterior_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x122\n\x13internal_block_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12*\n\x08expanded\x18\x03 \x03(\x0b2\x18.edgir.expr.ExportedExpr"S\n\nAssignExpr\x12!\n\x03dst\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x03src\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x97\x07\n\tValueExpr\x12&\n\x07literal\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLitH\x00\x12(\n\x06binary\x18\x02 \x01(\x0b2\x16.edgir.expr.BinaryExprH\x00\x12/\n\nbinary_set\x18\x12 \x01(\x0b2\x19.edgir.expr.BinarySetExprH\x00\x12&\n\x05unary\x18\x03 \x01(\x0b2\x15.edgir.expr.UnaryExprH\x00\x12-\n\tunary_set\x18\x04 \x01(\x0b2\x18.edgir.expr.UnarySetExprH\x00\x12&\n\x05array\x18\x06 \x01(\x0b2\x15.edgir.expr.ArrayExprH\x00\x12(\n\x06struct\x18\x07 \x01(\x0b2\x16.edgir.expr.StructExprH\x00\x12&\n\x05range\x18\x08 \x01(\x0b2\x15.edgir.expr.RangeExprH\x00\x120\n\nifThenElse\x18\n \x01(\x0b2\x1a.edgir.expr.IfThenElseExprH\x00\x12*\n\x07extract\x18\x0c \x01(\x0b2\x17.edgir.expr.ExtractExprH\x00\x121\n\x0bmap_extract\x18\x0e \x01(\x0b2\x1a.edgir.expr.MapExtractExprH\x00\x12.\n\tconnected\x18\x0f \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x12,\n\x08exported\x18\x10 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x123\n\x0econnectedArray\x18\x13 \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x121\n\rexportedArray\x18\x14 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12(\n\x06assign\x18\x11 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x122\n\x0eexportedTunnel\x18\x15 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12.\n\x0cassignTunnel\x18\x16 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x12#\n\x03ref\x18c \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04exprb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/expr.proto\x12\nedgir.expr\x1a\x0fedgir/ref.proto\x1a\x12edgir/common.proto\x1a\x0fedgir/lit.proto"\xb4\x01\n\tUnaryExpr\x12$\n\x02op\x18\x01 \x01(\x0e2\x18.edgir.expr.UnaryExpr.Op\x12"\n\x03val\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"]\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\n\n\x06NEGATE\x10\x01\x12\x07\n\x03NOT\x10\x02\x12\n\n\x06INVERT\x10\x03\x12\x07\n\x03MIN\x10\x04\x12\x07\n\x03MAX\x10\x05\x12\n\n\x06CENTER\x10\x06\x12\t\n\x05WIDTH\x10\x07"\x9f\x02\n\x0cUnarySetExpr\x12\'\n\x02op\x18\x01 \x01(\x0e2\x1b.edgir.expr.UnarySetExpr.Op\x12#\n\x04vals\x18\x04 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xc0\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03SUM\x10\x01\x12\x0c\n\x08ALL_TRUE\x10\x02\x12\x0c\n\x08ANY_TRUE\x10\x03\x12\n\n\x06ALL_EQ\x10\x04\x12\x0e\n\nALL_UNIQUE\x10\x05\x12\x0b\n\x07MAXIMUM\x10\n\x12\x0b\n\x07MINIMUM\x10\x0b\x12\x0f\n\x0bSET_EXTRACT\x10\x0c\x12\x10\n\x0cINTERSECTION\x10\r\x12\x08\n\x04HULL\x10\x0e\x12\n\n\x06NEGATE\x10\x14\x12\n\n\x06INVERT\x10\x15\x12\x0b\n\x07FLATTEN\x10\x1e"\xd4\x02\n\nBinaryExpr\x12%\n\x02op\x18\x01 \x01(\x0e2\x19.edgir.expr.BinaryExpr.Op\x12"\n\x03lhs\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr"\xd6\x01\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\x0f\n\x0bSHRINK_MULT\x107\x12\x07\n\x03AND\x10\x14\x12\x06\n\x02OR\x10\x15\x12\x07\n\x03XOR\x10\x16\x12\x0b\n\x07IMPLIES\x10\x17\x12\x06\n\x02EQ\x10\x1e\x12\x07\n\x03NEQ\x10\x1f\x12\x06\n\x02GT\x10(\x12\x07\n\x03GTE\x10)\x12\x06\n\x02LT\x10*\x12\x07\n\x03LTE\x10,\x12\x07\n\x03MAX\x10-\x12\x07\n\x03MIN\x10.\x12\x10\n\x0cINTERSECTION\x103\x12\x08\n\x04HULL\x106\x12\n\n\x06WITHIN\x105\x12\t\n\x05RANGE\x10\x01"\xbf\x01\n\rBinarySetExpr\x12(\n\x02op\x18\x01 \x01(\x0e2\x1c.edgir.expr.BinarySetExpr.Op\x12$\n\x05lhset\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03rhs\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr":\n\x02Op\x12\r\n\tUNDEFINED\x10\x00\x12\x07\n\x03ADD\x10\n\x12\x08\n\x04MULT\x10\x0c\x12\n\n\x06CONCAT\x10\x14\x12\x06\n\x02EQ\x10\x1e"0\n\tArrayExpr\x12#\n\x04vals\x18\x01 \x03(\x0b2\x15.edgir.expr.ValueExpr"[\n\tRangeExpr\x12&\n\x07minimum\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12&\n\x07maximum\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x80\x01\n\nStructExpr\x12.\n\x04vals\x18\x01 \x03(\x0b2 .edgir.expr.StructExpr.ValsEntry\x1aB\n\tValsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr:\x028\x01"\xa3\x01\n\x0eIfThenElseExpr\x12#\n\x04cond\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03tru\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x03fal\x18\x03 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"]\n\x0bExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12$\n\x05index\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"^\n\x0eMapExtractExpr\x12(\n\tcontainer\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12"\n\x04path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPath"\x91\x01\n\rConnectedExpr\x12)\n\nblock_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12(\n\tlink_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12+\n\x08expanded\x18\x03 \x03(\x0b2\x19.edgir.expr.ConnectedExpr"\x9c\x01\n\x0cExportedExpr\x12,\n\rexterior_port\x18\x01 \x01(\x0b2\x15.edgir.expr.ValueExpr\x122\n\x13internal_block_port\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr\x12*\n\x08expanded\x18\x03 \x03(\x0b2\x18.edgir.expr.ExportedExpr"S\n\nAssignExpr\x12!\n\x03dst\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x03src\x18\x02 \x01(\x0b2\x15.edgir.expr.ValueExpr"\x97\x07\n\tValueExpr\x12&\n\x07literal\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLitH\x00\x12(\n\x06binary\x18\x02 \x01(\x0b2\x16.edgir.expr.BinaryExprH\x00\x12/\n\nbinary_set\x18\x12 \x01(\x0b2\x19.edgir.expr.BinarySetExprH\x00\x12&\n\x05unary\x18\x03 \x01(\x0b2\x15.edgir.expr.UnaryExprH\x00\x12-\n\tunary_set\x18\x04 \x01(\x0b2\x18.edgir.expr.UnarySetExprH\x00\x12&\n\x05array\x18\x06 \x01(\x0b2\x15.edgir.expr.ArrayExprH\x00\x12(\n\x06struct\x18\x07 \x01(\x0b2\x16.edgir.expr.StructExprH\x00\x12&\n\x05range\x18\x08 \x01(\x0b2\x15.edgir.expr.RangeExprH\x00\x120\n\nifThenElse\x18\n \x01(\x0b2\x1a.edgir.expr.IfThenElseExprH\x00\x12*\n\x07extract\x18\x0c \x01(\x0b2\x17.edgir.expr.ExtractExprH\x00\x121\n\x0bmap_extract\x18\x0e \x01(\x0b2\x1a.edgir.expr.MapExtractExprH\x00\x12.\n\tconnected\x18\x0f \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x12,\n\x08exported\x18\x10 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x123\n\x0econnectedArray\x18\x13 \x01(\x0b2\x19.edgir.expr.ConnectedExprH\x00\x121\n\rexportedArray\x18\x14 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12(\n\x06assign\x18\x11 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x122\n\x0eexportedTunnel\x18\x15 \x01(\x0b2\x18.edgir.expr.ExportedExprH\x00\x12.\n\x0cassignTunnel\x18\x16 \x01(\x0b2\x16.edgir.expr.AssignExprH\x00\x12#\n\x03ref\x18c \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04exprb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.expr_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.expr_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _STRUCTEXPR_VALSENTRY._options = None - _STRUCTEXPR_VALSENTRY._serialized_options = b"8\x01" + _STRUCTEXPR_VALSENTRY._serialized_options = b'8\x01' _UNARYEXPR._serialized_start = 87 _UNARYEXPR._serialized_end = 267 _UNARYEXPR_OP._serialized_start = 174 @@ -32,28 +27,28 @@ _BINARYEXPR_OP._serialized_start = 686 _BINARYEXPR_OP._serialized_end = 900 _BINARYSETEXPR._serialized_start = 903 - _BINARYSETEXPR._serialized_end = 1086 + _BINARYSETEXPR._serialized_end = 1094 _BINARYSETEXPR_OP._serialized_start = 1036 - _BINARYSETEXPR_OP._serialized_end = 1086 - _ARRAYEXPR._serialized_start = 1088 - _ARRAYEXPR._serialized_end = 1136 - _RANGEEXPR._serialized_start = 1138 - _RANGEEXPR._serialized_end = 1229 - _STRUCTEXPR._serialized_start = 1232 - _STRUCTEXPR._serialized_end = 1360 - _STRUCTEXPR_VALSENTRY._serialized_start = 1294 - _STRUCTEXPR_VALSENTRY._serialized_end = 1360 - _IFTHENELSEEXPR._serialized_start = 1363 - _IFTHENELSEEXPR._serialized_end = 1526 - _EXTRACTEXPR._serialized_start = 1528 - _EXTRACTEXPR._serialized_end = 1621 - _MAPEXTRACTEXPR._serialized_start = 1623 - _MAPEXTRACTEXPR._serialized_end = 1717 - _CONNECTEDEXPR._serialized_start = 1720 - _CONNECTEDEXPR._serialized_end = 1865 - _EXPORTEDEXPR._serialized_start = 1868 - _EXPORTEDEXPR._serialized_end = 2024 - _ASSIGNEXPR._serialized_start = 2026 - _ASSIGNEXPR._serialized_end = 2109 - _VALUEEXPR._serialized_start = 2112 - _VALUEEXPR._serialized_end = 3031 + _BINARYSETEXPR_OP._serialized_end = 1094 + _ARRAYEXPR._serialized_start = 1096 + _ARRAYEXPR._serialized_end = 1144 + _RANGEEXPR._serialized_start = 1146 + _RANGEEXPR._serialized_end = 1237 + _STRUCTEXPR._serialized_start = 1240 + _STRUCTEXPR._serialized_end = 1368 + _STRUCTEXPR_VALSENTRY._serialized_start = 1302 + _STRUCTEXPR_VALSENTRY._serialized_end = 1368 + _IFTHENELSEEXPR._serialized_start = 1371 + _IFTHENELSEEXPR._serialized_end = 1534 + _EXTRACTEXPR._serialized_start = 1536 + _EXTRACTEXPR._serialized_end = 1629 + _MAPEXTRACTEXPR._serialized_start = 1631 + _MAPEXTRACTEXPR._serialized_end = 1725 + _CONNECTEDEXPR._serialized_start = 1728 + _CONNECTEDEXPR._serialized_end = 1873 + _EXPORTEDEXPR._serialized_start = 1876 + _EXPORTEDEXPR._serialized_end = 2032 + _ASSIGNEXPR._serialized_start = 2034 + _ASSIGNEXPR._serialized_end = 2117 + _VALUEEXPR._serialized_start = 2120 + _VALUEEXPR._serialized_end = 3039 \ No newline at end of file diff --git a/edg/edgir/expr_pb2.pyi b/edg/edgir/expr_pb2.pyi index 47241f6f9..2d1e15315 100644 --- a/edg/edgir/expr_pb2.pyi +++ b/edg/edgir/expr_pb2.pyi @@ -25,7 +25,6 @@ in a small number number of places to help classify types into groups. I don't think we should be using sorts at all in this module, but it's defined for the sake on completeness. """ - from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import lit_pb2 as _lit_pb2 @@ -37,7 +36,6 @@ from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -49,57 +47,62 @@ class UnaryExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType("ValueType", _builtins.int) + ValueType = _typing.NewType('ValueType', _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[UnaryExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: UnaryExpr._Op.ValueType NEGATE: UnaryExpr._Op.ValueType - "* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n " + '* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n ' NOT: UnaryExpr._Op.ValueType - "* Not :: Bool -> Bool" + '* Not :: Bool -> Bool' INVERT: UnaryExpr._Op.ValueType - "* Invert :: Float -> Float\n :: Range Float -> Range Float\n " + '* Invert :: Float -> Float\n :: Range Float -> Range Float\n ' MIN: UnaryExpr._Op.ValueType - "* Min :: Range a -> a" + '* Min :: Range a -> a' MAX: UnaryExpr._Op.ValueType - "* Max :: Range a -> a" + '* Max :: Range a -> a' CENTER: UnaryExpr._Op.ValueType - "* Center :: Range a -> a" + '* Center :: Range a -> a' WIDTH: UnaryExpr._Op.ValueType - "* Width :: Range a -> a" + '* Width :: Range a -> a' - class Op(_Op, metaclass=_OpEnumTypeWrapper): ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): + ... UNDEFINED: UnaryExpr.Op.ValueType NEGATE: UnaryExpr.Op.ValueType - "* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n " + '* Negate :: Numeric a => a -> a\n :: Numeric a => Range a -> Range a\n ' NOT: UnaryExpr.Op.ValueType - "* Not :: Bool -> Bool" + '* Not :: Bool -> Bool' INVERT: UnaryExpr.Op.ValueType - "* Invert :: Float -> Float\n :: Range Float -> Range Float\n " + '* Invert :: Float -> Float\n :: Range Float -> Range Float\n ' MIN: UnaryExpr.Op.ValueType - "* Min :: Range a -> a" + '* Min :: Range a -> a' MAX: UnaryExpr.Op.ValueType - "* Max :: Range a -> a" + '* Max :: Range a -> a' CENTER: UnaryExpr.Op.ValueType - "* Center :: Range a -> a" + '* Center :: Range a -> a' WIDTH: UnaryExpr.Op.ValueType - "* Width :: Range a -> a" + '* Width :: Range a -> a' OP_FIELD_NUMBER: _builtins.int VAL_FIELD_NUMBER: _builtins.int op: Global___UnaryExpr.Op.ValueType @_builtins.property - def val(self) -> Global___ValueExpr: ... - def __init__(self, *, op: Global___UnaryExpr.Op.ValueType = ..., val: Global___ValueExpr | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] + def val(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["op", b"op", "val", b"val"] + def __init__(self, *, op: Global___UnaryExpr.Op.ValueType=..., val: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['op', b'op', 'val', b'val'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___UnaryExpr: _TypeAlias = UnaryExpr @_typing.final @@ -107,83 +110,86 @@ class UnarySetExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType("ValueType", _builtins.int) + ValueType = _typing.NewType('ValueType', _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[UnarySetExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: UnarySetExpr._Op.ValueType SUM: UnarySetExpr._Op.ValueType - "* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n " + '* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n ' ALL_TRUE: UnarySetExpr._Op.ValueType - "* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n " + '* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n ' ANY_TRUE: UnarySetExpr._Op.ValueType - "* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n " + '* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n ' ALL_EQ: UnarySetExpr._Op.ValueType - "* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n " + '* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n ' ALL_UNIQUE: UnarySetExpr._Op.ValueType - "* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n " + '* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n ' MAXIMUM: UnarySetExpr._Op.ValueType - "SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " + 'SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' MINIMUM: UnarySetExpr._Op.ValueType - "* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " + '* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' SET_EXTRACT: UnarySetExpr._Op.ValueType - "* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n " + '* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n ' INTERSECTION: UnarySetExpr._Op.ValueType - "* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n " + '* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n ' HULL: UnarySetExpr._Op.ValueType - "* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n " + '* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n ' NEGATE: UnarySetExpr._Op.ValueType - "* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n " + '* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n ' INVERT: UnarySetExpr._Op.ValueType - "* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n " + '* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n ' FLATTEN: UnarySetExpr._Op.ValueType - "Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n " + 'Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n ' - class Op(_Op, metaclass=_OpEnumTypeWrapper): ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): + ... UNDEFINED: UnarySetExpr.Op.ValueType SUM: UnarySetExpr.Op.ValueType - "* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n " + '* Sum :: (Numeric a) => Set a -> a\n :: (Numeric a) => Set (Range a) -> Range a\n\n Sum({}) = 0\n ' ALL_TRUE: UnarySetExpr.Op.ValueType - "* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n " + '* All :: Set Bool -> Bool\n\n All inputs are true\n All({}) = True\n ' ANY_TRUE: UnarySetExpr.Op.ValueType - "* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n " + '* Any :: Set Bool -> Bool\n\n Any of the inputs are true\n Any({}) = False\n ' ALL_EQ: UnarySetExpr.Op.ValueType - "* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n " + '* AllEq :: (Equality a) => Set a -> Bool\n\n AllEq({}) = True\n ' ALL_UNIQUE: UnarySetExpr.Op.ValueType - "* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n " + '* AllUnique :: (Equality a) => Set a -> Bool\n\n AllUnique(EmptySet) = True\n ' MAXIMUM: UnarySetExpr.Op.ValueType - "SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " + 'SIZE = 6;\n\n * Maximum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' MINIMUM: UnarySetExpr.Op.ValueType - "* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n " + '* Minimum :: (Ordered a) => Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid.\n ' SET_EXTRACT: UnarySetExpr.Op.ValueType - "* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n " + '* SetExtract :: Set a -> a\n\n This op requires that the non-emptyness of the relevant set is assured\n before being valid. In addition this assumes all values in the set are equal.\n ' INTERSECTION: UnarySetExpr.Op.ValueType - "* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n " + '* Intersection :: Set (Range a) -> Range a\n\n May produce an empty range.\n Intersection({}) = [-inf, +inf]\n ' HULL: UnarySetExpr.Op.ValueType - "* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n " + '* Hull :: Set (Range a) -> Range a\n Returns the convex hull (union with all the inner missing bits filled in)\n Hull({}) = EmptyRange\n ' NEGATE: UnarySetExpr.Op.ValueType - "* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n " + '* Negate :: Numeric a => Set a -> Set a\n :: Numeric a => Set (Range a) -> Set (Range a)\n\n Pointwise negate\n ' INVERT: UnarySetExpr.Op.ValueType - "* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n " + '* Invert :: Set Float -> Set Float\n :: Set (Range Float) -> Set (Range Float)\n\n Pointwise Invert\n ' FLATTEN: UnarySetExpr.Op.ValueType - "Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n " + 'Flatten[A] : Set[Set[A]] -> Set[A]\n Given an array of array of elements, flattens the inner array.\n Alternatively stated, concatenates all of the elements of the outer arrary\n ' OP_FIELD_NUMBER: _builtins.int VALS_FIELD_NUMBER: _builtins.int op: Global___UnarySetExpr.Op.ValueType @_builtins.property - def vals(self) -> Global___ValueExpr: ... - def __init__( - self, *, op: Global___UnarySetExpr.Op.ValueType = ..., vals: Global___ValueExpr | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["vals", b"vals"] + def vals(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["op", b"op", "vals", b"vals"] + def __init__(self, *, op: Global___UnarySetExpr.Op.ValueType=..., vals: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['vals', b'vals'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['op', b'op', 'vals', b'vals'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___UnarySetExpr: _TypeAlias = UnarySetExpr @_typing.final @@ -191,114 +197,115 @@ class BinaryExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType("ValueType", _builtins.int) + ValueType = _typing.NewType('ValueType', _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[BinaryExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: BinaryExpr._Op.ValueType ADD: BinaryExpr._Op.ValueType - "* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " + '* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' MULT: BinaryExpr._Op.ValueType - "SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " + 'SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' SHRINK_MULT: BinaryExpr._Op.ValueType - "A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n " + 'A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n ' AND: BinaryExpr._Op.ValueType - "DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n " + 'DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n ' OR: BinaryExpr._Op.ValueType - "* Or :: (lhs :: Bool, rhs :: Bool) -> Bool" + '* Or :: (lhs :: Bool, rhs :: Bool) -> Bool' XOR: BinaryExpr._Op.ValueType - "* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool" + '* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool' IMPLIES: BinaryExpr._Op.ValueType - "* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool" + '* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool' EQ: BinaryExpr._Op.ValueType - "IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n " + 'IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n ' NEQ: BinaryExpr._Op.ValueType - "* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool" + '* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool' GT: BinaryExpr._Op.ValueType - "* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' GTE: BinaryExpr._Op.ValueType - "* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' LT: BinaryExpr._Op.ValueType - "* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' LTE: BinaryExpr._Op.ValueType - "* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' MAX: BinaryExpr._Op.ValueType - "* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a" + '* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a' MIN: BinaryExpr._Op.ValueType - "* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a" + '* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a' INTERSECTION: BinaryExpr._Op.ValueType - "UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n " + 'UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n ' HULL: BinaryExpr._Op.ValueType - "* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n " + '* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n ' WITHIN: BinaryExpr._Op.ValueType "INTERSECTS = 52;\n\n * Within :: (Numeric a) => (lhs :: Range a, rhs :: Range a) -> Bool\n :: (Numeric a) => (lhs :: a, rhs :: Range a) -> Bool\n\n Whether the lhs range or point is entirely within (contained by) the rhs.\n Used to be named SUBSET changed to a name that doesn't also imply a set op.\n " RANGE: BinaryExpr._Op.ValueType - "* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a" + '* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a' - class Op(_Op, metaclass=_OpEnumTypeWrapper): ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): + ... UNDEFINED: BinaryExpr.Op.ValueType ADD: BinaryExpr.Op.ValueType - "* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " + '* Add :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' MULT: BinaryExpr.Op.ValueType - "SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n " + 'SUB = 11; // Use ADD and NEGATE instead\n\n * Mult :: Numeric a => (lhs :: a, rhs :: a) -> a\n :: Numeric a => (lhs :: a, rhs :: Range a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: a) -> Range a\n :: Numeric a => (lhs :: Range a, rhs :: Range a) -> Range a\n ' SHRINK_MULT: BinaryExpr.Op.ValueType - "A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n " + 'A shrinking multiply operation for two Range types. Not commutative.\n See the documentation for shrink_multiply in the Python core HDL code for details.\n ' AND: BinaryExpr.Op.ValueType - "DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n " + 'DIV = 13; // Use MULT and INVERT instead\n\n * And :: (lhs :: Bool, rhs :: Bool) -> Bool\n ' OR: BinaryExpr.Op.ValueType - "* Or :: (lhs :: Bool, rhs :: Bool) -> Bool" + '* Or :: (lhs :: Bool, rhs :: Bool) -> Bool' XOR: BinaryExpr.Op.ValueType - "* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool" + '* Xor :: (lhs :: Bool, rhs :: Bool) -> Bool' IMPLIES: BinaryExpr.Op.ValueType - "* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool" + '* Implies :: (lhs :: Bool, rhs :: Bool) -> Bool' EQ: BinaryExpr.Op.ValueType - "IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n " + 'IFF = 24; // Use EQ instead\n\n * Eq :: (Equality a) => (lhs :: a, rhs :: a) -> Bool\n ' NEQ: BinaryExpr.Op.ValueType - "* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool" + '* Neq :: (Equality a) => (lhs :: a, rhs : a) -> Bool' GT: BinaryExpr.Op.ValueType - "* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* GT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' GTE: BinaryExpr.Op.ValueType - "* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* GTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' LT: BinaryExpr.Op.ValueType - "* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* LT :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' LTE: BinaryExpr.Op.ValueType - "* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool" + '* LTE :: (Comparable a) => (lhs :: a, rhs :: a) -> Bool' MAX: BinaryExpr.Op.ValueType - "* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a" + '* Max :: (Comparable a) => (lhs :: a, rhs :: a) -> a' MIN: BinaryExpr.Op.ValueType - "* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a" + '* Min :: (Comparable a) => (lhs :: a, rhs :: a) -> a' INTERSECTION: BinaryExpr.Op.ValueType - "UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n " + 'UNION = 50;\n\n * Intersection :: (Numeric a) => (lhs : Range a, rhs : Range a) -> Range a\n ' HULL: BinaryExpr.Op.ValueType - "* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n " + '* Hull :: (lhs :: Range a, rhs :: Range a) -> Range a\n Given two input ranges, returns the convex hull (union with\n all the inner missing bits filled in)\n ' WITHIN: BinaryExpr.Op.ValueType "INTERSECTS = 52;\n\n * Within :: (Numeric a) => (lhs :: Range a, rhs :: Range a) -> Bool\n :: (Numeric a) => (lhs :: a, rhs :: Range a) -> Bool\n\n Whether the lhs range or point is entirely within (contained by) the rhs.\n Used to be named SUBSET changed to a name that doesn't also imply a set op.\n " RANGE: BinaryExpr.Op.ValueType - "* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a" + '* Range :: (Comparable a) => (lower :: a, upper :: a) -> Range a' OP_FIELD_NUMBER: _builtins.int LHS_FIELD_NUMBER: _builtins.int RHS_FIELD_NUMBER: _builtins.int op: Global___BinaryExpr.Op.ValueType @_builtins.property - def lhs(self) -> Global___ValueExpr: ... + def lhs(self) -> Global___ValueExpr: + ... + @_builtins.property - def rhs(self) -> Global___ValueExpr: ... - def __init__( - self, - *, - op: Global___BinaryExpr.Op.ValueType = ..., - lhs: Global___ValueExpr | None = ..., - rhs: Global___ValueExpr | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["lhs", b"lhs", "rhs", b"rhs"] + def rhs(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["lhs", b"lhs", "op", b"op", "rhs", b"rhs"] + def __init__(self, *, op: Global___BinaryExpr.Op.ValueType=..., lhs: Global___ValueExpr | None=..., rhs: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['lhs', b'lhs', 'rhs', b'rhs'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['lhs', b'lhs', 'op', b'op', 'rhs', b'rhs'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___BinaryExpr: _TypeAlias = BinaryExpr @_typing.final @@ -306,66 +313,73 @@ class BinarySetExpr(_message.Message): DESCRIPTOR: _descriptor.Descriptor class _Op: - ValueType = _typing.NewType("ValueType", _builtins.int) + ValueType = _typing.NewType('ValueType', _builtins.int) V: _TypeAlias = ValueType class _OpEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[BinarySetExpr._Op.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: BinarySetExpr._Op.ValueType ADD: BinarySetExpr._Op.ValueType - "* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " + '* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' MULT: BinarySetExpr._Op.ValueType - "* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " + '* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' CONCAT: BinarySetExpr._Op.ValueType - "String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n " + 'String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n ' + EQ: BinarySetExpr._Op.ValueType + 'Equality operator\n (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element)\n ' - class Op(_Op, metaclass=_OpEnumTypeWrapper): ... + class Op(_Op, metaclass=_OpEnumTypeWrapper): + ... UNDEFINED: BinarySetExpr.Op.ValueType ADD: BinarySetExpr.Op.ValueType - "* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " + '* Add :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' MULT: BinarySetExpr.Op.ValueType - "* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n " + '* Mult :: Numeric a => (lhset : Set a, rhs : a) -> Set a\n :: Numeric a => (lhset : Set a, rhs : Range a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : a) -> Set (Range a)\n :: Numeric a => (lhset : Set (Range a), rhs : Range a) -> Set (Range a)\n ' CONCAT: BinarySetExpr.Op.ValueType - "String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n " + 'String concatenate operator\n Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements)\n : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements)\n ' + EQ: BinarySetExpr.Op.ValueType + 'Equality operator\n (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element)\n ' OP_FIELD_NUMBER: _builtins.int LHSET_FIELD_NUMBER: _builtins.int RHS_FIELD_NUMBER: _builtins.int op: Global___BinarySetExpr.Op.ValueType @_builtins.property - def lhset(self) -> Global___ValueExpr: ... + def lhset(self) -> Global___ValueExpr: + ... + @_builtins.property - def rhs(self) -> Global___ValueExpr: ... - def __init__( - self, - *, - op: Global___BinarySetExpr.Op.ValueType = ..., - lhset: Global___ValueExpr | None = ..., - rhs: Global___ValueExpr | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["lhset", b"lhset", "rhs", b"rhs"] + def rhs(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["lhset", b"lhset", "op", b"op", "rhs", b"rhs"] + def __init__(self, *, op: Global___BinarySetExpr.Op.ValueType=..., lhset: Global___ValueExpr | None=..., rhs: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['lhset', b'lhset', 'rhs', b'rhs'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['lhset', b'lhset', 'op', b'op', 'rhs', b'rhs'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___BinarySetExpr: _TypeAlias = BinarySetExpr @_typing.final class ArrayExpr(_message.Message): """* Creates an array from element exprs""" - DESCRIPTOR: _descriptor.Descriptor VALS_FIELD_NUMBER: _builtins.int @_builtins.property - def vals(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueExpr]: ... - def __init__(self, *, vals: _abc.Iterable[Global___ValueExpr] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["vals", b"vals"] + def vals(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueExpr]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, vals: _abc.Iterable[Global___ValueExpr] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['vals', b'vals'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ArrayExpr: _TypeAlias = ArrayExpr @_typing.final @@ -373,25 +387,28 @@ class RangeExpr(_message.Message): """* Ranges have an expression form, allowing you to constrain them without specifying them fully """ - DESCRIPTOR: _descriptor.Descriptor MINIMUM_FIELD_NUMBER: _builtins.int MAXIMUM_FIELD_NUMBER: _builtins.int @_builtins.property - def minimum(self) -> Global___ValueExpr: ... + def minimum(self) -> Global___ValueExpr: + ... + @_builtins.property - def maximum(self) -> Global___ValueExpr: ... - def __init__( - self, *, minimum: Global___ValueExpr | None = ..., maximum: Global___ValueExpr | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] + def maximum(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] + def __init__(self, *, minimum: Global___ValueExpr | None=..., maximum: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___RangeExpr: _TypeAlias = RangeExpr @_typing.final @@ -399,7 +416,6 @@ class StructExpr(_message.Message): """* Structs have an expression form, allowing you to constrain them without specifying them fully """ - DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -410,30 +426,36 @@ class StructExpr(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___ValueExpr: ... - def __init__(self, *, key: _builtins.str = ..., value: Global___ValueExpr | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] + def __init__(self, *, key: _builtins.str=..., value: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... VALS_FIELD_NUMBER: _builtins.int @_builtins.property - def vals(self) -> _containers.MessageMap[_builtins.str, Global___ValueExpr]: ... - def __init__(self, *, vals: _abc.Mapping[_builtins.str, Global___ValueExpr] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["vals", b"vals"] + def vals(self) -> _containers.MessageMap[_builtins.str, Global___ValueExpr]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, vals: _abc.Mapping[_builtins.str, Global___ValueExpr] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['vals', b'vals'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___StructExpr: _TypeAlias = StructExpr @_typing.final class IfThenElseExpr(_message.Message): """* IfThenElse :: (cond :: Bool, tru :: a, fal :: a) -> a""" - DESCRIPTOR: _descriptor.Descriptor COND_FIELD_NUMBER: _builtins.int TRU_FIELD_NUMBER: _builtins.int @@ -441,28 +463,31 @@ class IfThenElseExpr(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def cond(self) -> Global___ValueExpr: ... + def cond(self) -> Global___ValueExpr: + ... + @_builtins.property - def tru(self) -> Global___ValueExpr: ... + def tru(self) -> Global___ValueExpr: + ... + @_builtins.property - def fal(self) -> Global___ValueExpr: ... + def fal(self) -> Global___ValueExpr: + ... + @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - cond: Global___ValueExpr | None = ..., - tru: Global___ValueExpr | None = ..., - fal: Global___ValueExpr | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["cond", b"cond", "fal", b"fal", "meta", b"meta", "tru", b"tru"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["cond", b"cond", "fal", b"fal", "meta", b"meta", "tru", b"tru"] + def __init__(self, *, cond: Global___ValueExpr | None=..., tru: Global___ValueExpr | None=..., fal: Global___ValueExpr | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['cond', b'cond', 'fal', b'fal', 'meta', b'meta', 'tru', b'tru'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['cond', b'cond', 'fal', b'fal', 'meta', b'meta', 'tru', b'tru'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___IfThenElseExpr: _TypeAlias = IfThenElseExpr @_typing.final @@ -471,54 +496,60 @@ class ExtractExpr(_message.Message): Extract :: (container :: Struct{index :: a}, index :: string) -> a Extract :: (container :: Range a , index :: {"minimum"|"maximum"}) -> a """ - DESCRIPTOR: _descriptor.Descriptor CONTAINER_FIELD_NUMBER: _builtins.int INDEX_FIELD_NUMBER: _builtins.int @_builtins.property - def container(self) -> Global___ValueExpr: ... + def container(self) -> Global___ValueExpr: + ... + @_builtins.property - def index(self) -> Global___ValueExpr: ... - def __init__( - self, *, container: Global___ValueExpr | None = ..., index: Global___ValueExpr | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "index", b"index"] + def index(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "index", b"index"] + def __init__(self, *, container: Global___ValueExpr | None=..., index: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'index', b'index'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'index', b'index'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ExtractExpr: _TypeAlias = ExtractExpr @_typing.final class MapExtractExpr(_message.Message): """/** MapExtract :: (container :: Array a , path :: LocalRef{from :: a, to :: b}) -> Array b - MapExtract :: (container :: Set a , path :: LocalRef{from :: a, to :: b}) -> Set b + MapExtract :: (container :: Set a , path :: LocalRef{from :: a, to :: b}) -> Set b - This expression can map over a container and return a container of - the relevant subexpression determined by a path. */ + This expression can map over a container and return a container of + the relevant subexpression determined by a path. */ """ - DESCRIPTOR: _descriptor.Descriptor CONTAINER_FIELD_NUMBER: _builtins.int PATH_FIELD_NUMBER: _builtins.int @_builtins.property - def container(self) -> Global___ValueExpr: ... + def container(self) -> Global___ValueExpr: + ... + @_builtins.property - def path(self) -> _ref_pb2.LocalPath: ... - def __init__( - self, *, container: Global___ValueExpr | None = ..., path: _ref_pb2.LocalPath | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "path", b"path"] + def path(self) -> _ref_pb2.LocalPath: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["container", b"container", "path", b"path"] + def __init__(self, *, container: Global___ValueExpr | None=..., path: _ref_pb2.LocalPath | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'path', b'path'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['container', b'container', 'path', b'path'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___MapExtractExpr: _TypeAlias = MapExtractExpr @_typing.final @@ -527,16 +558,19 @@ class ConnectedExpr(_message.Message): This tells us whether the specified ports are connected """ - DESCRIPTOR: _descriptor.Descriptor BLOCK_PORT_FIELD_NUMBER: _builtins.int LINK_PORT_FIELD_NUMBER: _builtins.int EXPANDED_FIELD_NUMBER: _builtins.int @_builtins.property - def block_port(self) -> Global___ValueExpr: ... + def block_port(self) -> Global___ValueExpr: + ... + @_builtins.property - def link_port(self) -> Global___ValueExpr: ... + def link_port(self) -> Global___ValueExpr: + ... + @_builtins.property def expanded(self) -> _containers.RepeatedCompositeFieldContainer[Global___ConnectedExpr]: """During compilation, ConnectedExpr may be expanded (allocate replaced with concrete path indices, @@ -545,22 +579,16 @@ class ConnectedExpr(_message.Message): while the original (parent) is not modified. """ - def __init__( - self, - *, - block_port: Global___ValueExpr | None = ..., - link_port: Global___ValueExpr | None = ..., - expanded: _abc.Iterable[Global___ConnectedExpr] | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["block_port", b"block_port", "link_port", b"link_port"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "block_port", b"block_port", "expanded", b"expanded", "link_port", b"link_port" - ] + def __init__(self, *, block_port: Global___ValueExpr | None=..., link_port: Global___ValueExpr | None=..., expanded: _abc.Iterable[Global___ConnectedExpr] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['block_port', b'block_port', 'link_port', b'link_port'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['block_port', b'block_port', 'expanded', b'expanded', 'link_port', b'link_port'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ConnectedExpr: _TypeAlias = ConnectedExpr @_typing.final @@ -569,38 +597,33 @@ class ExportedExpr(_message.Message): This tells us whether the specified port is exported to the hierarchy block exterior port """ - DESCRIPTOR: _descriptor.Descriptor EXTERIOR_PORT_FIELD_NUMBER: _builtins.int INTERNAL_BLOCK_PORT_FIELD_NUMBER: _builtins.int EXPANDED_FIELD_NUMBER: _builtins.int @_builtins.property - def exterior_port(self) -> Global___ValueExpr: ... + def exterior_port(self) -> Global___ValueExpr: + ... + @_builtins.property - def internal_block_port(self) -> Global___ValueExpr: ... + def internal_block_port(self) -> Global___ValueExpr: + ... + @_builtins.property def expanded(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExportedExpr]: """see comment in ConnectedExpr""" - def __init__( - self, - *, - exterior_port: Global___ValueExpr | None = ..., - internal_block_port: Global___ValueExpr | None = ..., - expanded: _abc.Iterable[Global___ExportedExpr] | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "exterior_port", b"exterior_port", "internal_block_port", b"internal_block_port" - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "expanded", b"expanded", "exterior_port", b"exterior_port", "internal_block_port", b"internal_block_port" - ] + def __init__(self, *, exterior_port: Global___ValueExpr | None=..., internal_block_port: Global___ValueExpr | None=..., expanded: _abc.Iterable[Global___ExportedExpr] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['exterior_port', b'exterior_port', 'internal_block_port', b'internal_block_port'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['expanded', b'expanded', 'exterior_port', b'exterior_port', 'internal_block_port', b'internal_block_port'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ExportedExpr: _TypeAlias = ExportedExpr @_typing.final @@ -608,23 +631,28 @@ class AssignExpr(_message.Message): """Variable assignment (from an expression value), which allows dataflow to be directioned and explicit. Assignments should not be cyclic. """ - DESCRIPTOR: _descriptor.Descriptor DST_FIELD_NUMBER: _builtins.int SRC_FIELD_NUMBER: _builtins.int @_builtins.property - def dst(self) -> _ref_pb2.LocalPath: ... + def dst(self) -> _ref_pb2.LocalPath: + ... + @_builtins.property - def src(self) -> Global___ValueExpr: ... - def __init__(self, *, dst: _ref_pb2.LocalPath | None = ..., src: Global___ValueExpr | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["dst", b"dst", "src", b"src"] + def src(self) -> Global___ValueExpr: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["dst", b"dst", "src", b"src"] + def __init__(self, *, dst: _ref_pb2.LocalPath | None=..., src: Global___ValueExpr | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['dst', b'dst', 'src', b'src'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['dst', b'dst', 'src', b'src'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___AssignExpr: _TypeAlias = AssignExpr @_typing.final @@ -652,29 +680,49 @@ class ValueExpr(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def literal(self) -> _lit_pb2.ValueLit: ... + def literal(self) -> _lit_pb2.ValueLit: + ... + @_builtins.property - def binary(self) -> Global___BinaryExpr: ... + def binary(self) -> Global___BinaryExpr: + ... + @_builtins.property - def binary_set(self) -> Global___BinarySetExpr: ... + def binary_set(self) -> Global___BinarySetExpr: + ... + @_builtins.property - def unary(self) -> Global___UnaryExpr: ... + def unary(self) -> Global___UnaryExpr: + ... + @_builtins.property - def unary_set(self) -> Global___UnarySetExpr: ... + def unary_set(self) -> Global___UnarySetExpr: + ... + @_builtins.property def array(self) -> Global___ArrayExpr: """SetExpr set = 5;""" @_builtins.property - def struct(self) -> Global___StructExpr: ... + def struct(self) -> Global___StructExpr: + ... + @_builtins.property - def range(self) -> Global___RangeExpr: ... + def range(self) -> Global___RangeExpr: + ... + @_builtins.property - def ifThenElse(self) -> Global___IfThenElseExpr: ... + def ifThenElse(self) -> Global___IfThenElseExpr: + ... + @_builtins.property - def extract(self) -> Global___ExtractExpr: ... + def extract(self) -> Global___ExtractExpr: + ... + @_builtins.property - def map_extract(self) -> Global___MapExtractExpr: ... + def map_extract(self) -> Global___MapExtractExpr: + ... + @_builtins.property def connected(self) -> Global___ConnectedExpr: """single port to single port connect""" @@ -692,7 +740,9 @@ class ValueExpr(_message.Message): """array to array export, where allocate means allocate a subarray""" @_builtins.property - def assign(self) -> Global___AssignExpr: ... + def assign(self) -> Global___AssignExpr: + ... + @_builtins.property def exportedTunnel(self) -> Global___ExportedExpr: """These Exprs support cross-hierarchy operations @@ -714,148 +764,26 @@ class ValueExpr(_message.Message): """ @_builtins.property - def ref(self) -> _ref_pb2.LocalPath: ... - @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - literal: _lit_pb2.ValueLit | None = ..., - binary: Global___BinaryExpr | None = ..., - binary_set: Global___BinarySetExpr | None = ..., - unary: Global___UnaryExpr | None = ..., - unary_set: Global___UnarySetExpr | None = ..., - array: Global___ArrayExpr | None = ..., - struct: Global___StructExpr | None = ..., - range: Global___RangeExpr | None = ..., - ifThenElse: Global___IfThenElseExpr | None = ..., - extract: Global___ExtractExpr | None = ..., - map_extract: Global___MapExtractExpr | None = ..., - connected: Global___ConnectedExpr | None = ..., - exported: Global___ExportedExpr | None = ..., - connectedArray: Global___ConnectedExpr | None = ..., - exportedArray: Global___ExportedExpr | None = ..., - assign: Global___AssignExpr | None = ..., - exportedTunnel: Global___ExportedExpr | None = ..., - assignTunnel: Global___AssignExpr | None = ..., - ref: _ref_pb2.LocalPath | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "array", - b"array", - "assign", - b"assign", - "assignTunnel", - b"assignTunnel", - "binary", - b"binary", - "binary_set", - b"binary_set", - "connected", - b"connected", - "connectedArray", - b"connectedArray", - "exported", - b"exported", - "exportedArray", - b"exportedArray", - "exportedTunnel", - b"exportedTunnel", - "expr", - b"expr", - "extract", - b"extract", - "ifThenElse", - b"ifThenElse", - "literal", - b"literal", - "map_extract", - b"map_extract", - "meta", - b"meta", - "range", - b"range", - "ref", - b"ref", - "struct", - b"struct", - "unary", - b"unary", - "unary_set", - b"unary_set", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "array", - b"array", - "assign", - b"assign", - "assignTunnel", - b"assignTunnel", - "binary", - b"binary", - "binary_set", - b"binary_set", - "connected", - b"connected", - "connectedArray", - b"connectedArray", - "exported", - b"exported", - "exportedArray", - b"exportedArray", - "exportedTunnel", - b"exportedTunnel", - "expr", - b"expr", - "extract", - b"extract", - "ifThenElse", - b"ifThenElse", - "literal", - b"literal", - "map_extract", - b"map_extract", - "meta", - b"meta", - "range", - b"range", - "ref", - b"ref", - "struct", - b"struct", - "unary", - b"unary", - "unary_set", - b"unary_set", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_expr: _TypeAlias = _typing.Literal[ - "literal", - "binary", - "binary_set", - "unary", - "unary_set", - "array", - "struct", - "range", - "ifThenElse", - "extract", - "map_extract", - "connected", - "exported", - "connectedArray", - "exportedArray", - "assign", - "exportedTunnel", - "assignTunnel", - "ref", - ] - _WhichOneofArgType_expr: _TypeAlias = _typing.Literal["expr", b"expr"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_expr) -> _WhichOneofReturnType_expr | None: ... - -Global___ValueExpr: _TypeAlias = ValueExpr + def ref(self) -> _ref_pb2.LocalPath: + ... + + @_builtins.property + def meta(self) -> _common_pb2.Metadata: + ... + + def __init__(self, *, literal: _lit_pb2.ValueLit | None=..., binary: Global___BinaryExpr | None=..., binary_set: Global___BinarySetExpr | None=..., unary: Global___UnaryExpr | None=..., unary_set: Global___UnarySetExpr | None=..., array: Global___ArrayExpr | None=..., struct: Global___StructExpr | None=..., range: Global___RangeExpr | None=..., ifThenElse: Global___IfThenElseExpr | None=..., extract: Global___ExtractExpr | None=..., map_extract: Global___MapExtractExpr | None=..., connected: Global___ConnectedExpr | None=..., exported: Global___ExportedExpr | None=..., connectedArray: Global___ConnectedExpr | None=..., exportedArray: Global___ExportedExpr | None=..., assign: Global___AssignExpr | None=..., exportedTunnel: Global___ExportedExpr | None=..., assignTunnel: Global___AssignExpr | None=..., ref: _ref_pb2.LocalPath | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'assign', b'assign', 'assignTunnel', b'assignTunnel', 'binary', b'binary', 'binary_set', b'binary_set', 'connected', b'connected', 'connectedArray', b'connectedArray', 'exported', b'exported', 'exportedArray', b'exportedArray', 'exportedTunnel', b'exportedTunnel', 'expr', b'expr', 'extract', b'extract', 'ifThenElse', b'ifThenElse', 'literal', b'literal', 'map_extract', b'map_extract', 'meta', b'meta', 'range', b'range', 'ref', b'ref', 'struct', b'struct', 'unary', b'unary', 'unary_set', b'unary_set'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'assign', b'assign', 'assignTunnel', b'assignTunnel', 'binary', b'binary', 'binary_set', b'binary_set', 'connected', b'connected', 'connectedArray', b'connectedArray', 'exported', b'exported', 'exportedArray', b'exportedArray', 'exportedTunnel', b'exportedTunnel', 'expr', b'expr', 'extract', b'extract', 'ifThenElse', b'ifThenElse', 'literal', b'literal', 'map_extract', b'map_extract', 'meta', b'meta', 'range', b'range', 'ref', b'ref', 'struct', b'struct', 'unary', b'unary', 'unary_set', b'unary_set'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_expr: _TypeAlias = _typing.Literal['literal', 'binary', 'binary_set', 'unary', 'unary_set', 'array', 'struct', 'range', 'ifThenElse', 'extract', 'map_extract', 'connected', 'exported', 'connectedArray', 'exportedArray', 'assign', 'exportedTunnel', 'assignTunnel', 'ref'] + _WhichOneofArgType_expr: _TypeAlias = _typing.Literal['expr', b'expr'] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_expr) -> _WhichOneofReturnType_expr | None: + ... +Global___ValueExpr: _TypeAlias = ValueExpr \ No newline at end of file diff --git a/edg/edgir/impl_pb2.py b/edg/edgir/impl_pb2.py index 2392b5cbe..47e51e529 100644 --- a/edg/edgir/impl_pb2.py +++ b/edg/edgir/impl_pb2.py @@ -1,18 +1,13 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x10edgir/impl.proto\x12\nedgir.impl\x1a\x12edgir/common.proto"1\n\tBlockImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08PortImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08LinkImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"7\n\x0fEnvironmentImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/impl.proto\x12\nedgir.impl\x1a\x12edgir/common.proto"1\n\tBlockImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08PortImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"0\n\x08LinkImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata"7\n\x0fEnvironmentImpl\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.impl_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.impl_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _BLOCKIMPL._serialized_start = 52 @@ -22,4 +17,4 @@ _LINKIMPL._serialized_start = 153 _LINKIMPL._serialized_end = 201 _ENVIRONMENTIMPL._serialized_start = 203 - _ENVIRONMENTIMPL._serialized_end = 258 + _ENVIRONMENTIMPL._serialized_end = 258 \ No newline at end of file diff --git a/edg/edgir/impl_pb2.pyi b/edg/edgir/impl_pb2.pyi index 3169fd28a..a38a4ffdd 100644 --- a/edg/edgir/impl_pb2.pyi +++ b/edg/edgir/impl_pb2.pyi @@ -10,14 +10,12 @@ stored. Fuck if I know what that will look like, so for now you just get a metadata block. """ - from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -30,15 +28,19 @@ class BlockImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___BlockImpl: _TypeAlias = BlockImpl @_typing.final @@ -47,15 +49,19 @@ class PortImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___PortImpl: _TypeAlias = PortImpl @_typing.final @@ -64,15 +70,19 @@ class LinkImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___LinkImpl: _TypeAlias = LinkImpl @_typing.final @@ -81,13 +91,17 @@ class EnvironmentImpl(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__(self, *, meta: _common_pb2.Metadata | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def __init__(self, *, meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] -Global___EnvironmentImpl: _TypeAlias = EnvironmentImpl + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... +Global___EnvironmentImpl: _TypeAlias = EnvironmentImpl \ No newline at end of file diff --git a/edg/edgir/init_pb2.py b/edg/edgir/init_pb2.py index 6b6964627..92571bac8 100644 --- a/edg/edgir/init_pb2.py +++ b/edg/edgir/init_pb2.py @@ -1,19 +1,14 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x10edgir/init.proto\x12\nedgir.init\x1a\x12edgir/common.proto"\xeb\x02\n\x07ValInit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07integer\x18\x02 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07boolean\x18\x03 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12#\n\x04text\x18\x04 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12"\n\x03set\x18\x08 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12%\n\x06struct\x18\t \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.init.ValInitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x05\n\x03valb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/init.proto\x12\nedgir.init\x1a\x12edgir/common.proto"\xeb\x02\n\x07ValInit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07integer\x18\x02 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12&\n\x07boolean\x18\x03 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12#\n\x04text\x18\x04 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12"\n\x03set\x18\x08 \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12%\n\x06struct\x18\t \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.common.EmptyH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.init.ValInitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x05\n\x03valb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.init_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.init_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _VALINIT._serialized_start = 53 - _VALINIT._serialized_end = 416 + _VALINIT._serialized_end = 416 \ No newline at end of file diff --git a/edg/edgir/init_pb2.pyi b/edg/edgir/init_pb2.pyi index dce1504c7..534446937 100644 --- a/edg/edgir/init_pb2.pyi +++ b/edg/edgir/init_pb2.pyi @@ -11,14 +11,12 @@ creating a value. FIXME :: Does this make more sense in another file? """ - from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -32,7 +30,6 @@ class ValInit(_message.Message): I think the frontend should have more type specific wrappers around this since the data required for each type can be different. """ - DESCRIPTOR: _descriptor.Descriptor FLOATING_FIELD_NUMBER: _builtins.int INTEGER_FIELD_NUMBER: _builtins.int @@ -45,89 +42,54 @@ class ValInit(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def floating(self) -> _common_pb2.Empty: ... + def floating(self) -> _common_pb2.Empty: + ... + @_builtins.property - def integer(self) -> _common_pb2.Empty: ... + def integer(self) -> _common_pb2.Empty: + ... + @_builtins.property - def boolean(self) -> _common_pb2.Empty: ... + def boolean(self) -> _common_pb2.Empty: + ... + @_builtins.property - def text(self) -> _common_pb2.Empty: ... + def text(self) -> _common_pb2.Empty: + ... + @_builtins.property - def set(self) -> _common_pb2.Empty: ... + def set(self) -> _common_pb2.Empty: + ... + @_builtins.property - def struct(self) -> _common_pb2.Empty: ... + def struct(self) -> _common_pb2.Empty: + ... + @_builtins.property - def range(self) -> _common_pb2.Empty: ... + def range(self) -> _common_pb2.Empty: + ... + @_builtins.property - def array(self) -> Global___ValInit: ... + def array(self) -> Global___ValInit: + ... + @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - floating: _common_pb2.Empty | None = ..., - integer: _common_pb2.Empty | None = ..., - boolean: _common_pb2.Empty | None = ..., - text: _common_pb2.Empty | None = ..., - set: _common_pb2.Empty | None = ..., - struct: _common_pb2.Empty | None = ..., - range: _common_pb2.Empty | None = ..., - array: Global___ValInit | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "array", - b"array", - "boolean", - b"boolean", - "floating", - b"floating", - "integer", - b"integer", - "meta", - b"meta", - "range", - b"range", - "set", - b"set", - "struct", - b"struct", - "text", - b"text", - "val", - b"val", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "array", - b"array", - "boolean", - b"boolean", - "floating", - b"floating", - "integer", - b"integer", - "meta", - b"meta", - "range", - b"range", - "set", - b"set", - "struct", - b"struct", - "text", - b"text", - "val", - b"val", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_val: _TypeAlias = _typing.Literal[ - "floating", "integer", "boolean", "text", "set", "struct", "range", "array" - ] - _WhichOneofArgType_val: _TypeAlias = _typing.Literal["val", b"val"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_val) -> _WhichOneofReturnType_val | None: ... - -Global___ValInit: _TypeAlias = ValInit + def meta(self) -> _common_pb2.Metadata: + ... + + def __init__(self, *, floating: _common_pb2.Empty | None=..., integer: _common_pb2.Empty | None=..., boolean: _common_pb2.Empty | None=..., text: _common_pb2.Empty | None=..., set: _common_pb2.Empty | None=..., struct: _common_pb2.Empty | None=..., range: _common_pb2.Empty | None=..., array: Global___ValInit | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'set', b'set', 'struct', b'struct', 'text', b'text', 'val', b'val'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'set', b'set', 'struct', b'struct', 'text', b'text', 'val', b'val'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_val: _TypeAlias = _typing.Literal['floating', 'integer', 'boolean', 'text', 'set', 'struct', 'range', 'array'] + _WhichOneofArgType_val: _TypeAlias = _typing.Literal['val', b'val'] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_val) -> _WhichOneofReturnType_val | None: + ... +Global___ValInit: _TypeAlias = ValInit \ No newline at end of file diff --git a/edg/edgir/lit_pb2.py b/edg/edgir/lit_pb2.py index 5fa7a1533..96d84789c 100644 --- a/edg/edgir/lit_pb2.py +++ b/edg/edgir/lit_pb2.py @@ -1,22 +1,17 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x0fedgir/lit.proto\x12\tedgir.lit\x1a\x12edgir/common.proto"\x17\n\x08FloatLit\x12\x0b\n\x03val\x18\x01 \x01(\x01"\x15\n\x06IntLit\x12\x0b\n\x03val\x18\x01 \x01(\x12"\x16\n\x07BoolLit\x12\x0b\n\x03val\x18\x01 \x01(\x08"\x16\n\x07TextLit\x12\x0b\n\x03val\x18\x01 \x01(\t"V\n\x08RangeLit\x12$\n\x07minimum\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLit\x12$\n\x07maximum\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"\x84\x01\n\tStructLit\x122\n\x07members\x18\x01 \x03(\x0b2!.edgir.lit.StructLit.MembersEntry\x1aC\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit:\x028\x01"-\n\x08ArrayLit\x12!\n\x04elts\x18\x01 \x03(\x0b2\x13.edgir.lit.ValueLit"\xc6\x02\n\x08ValueLit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.lit.FloatLitH\x00\x12$\n\x07integer\x18\x02 \x01(\x0b2\x11.edgir.lit.IntLitH\x00\x12%\n\x07boolean\x18\x03 \x01(\x0b2\x12.edgir.lit.BoolLitH\x00\x12"\n\x04text\x18\x04 \x01(\x0b2\x12.edgir.lit.TextLitH\x00\x12&\n\x06struct\x18\t \x01(\x0b2\x14.edgir.lit.StructLitH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.lit.RangeLitH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.lit.ArrayLitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04typeb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0fedgir/lit.proto\x12\tedgir.lit\x1a\x12edgir/common.proto"\x17\n\x08FloatLit\x12\x0b\n\x03val\x18\x01 \x01(\x01"\x15\n\x06IntLit\x12\x0b\n\x03val\x18\x01 \x01(\x12"\x16\n\x07BoolLit\x12\x0b\n\x03val\x18\x01 \x01(\x08"\x16\n\x07TextLit\x12\x0b\n\x03val\x18\x01 \x01(\t"V\n\x08RangeLit\x12$\n\x07minimum\x18\x01 \x01(\x0b2\x13.edgir.lit.ValueLit\x12$\n\x07maximum\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"\x84\x01\n\tStructLit\x122\n\x07members\x18\x01 \x03(\x0b2!.edgir.lit.StructLit.MembersEntry\x1aC\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit:\x028\x01"-\n\x08ArrayLit\x12!\n\x04elts\x18\x01 \x03(\x0b2\x13.edgir.lit.ValueLit"\xc6\x02\n\x08ValueLit\x12\'\n\x08floating\x18\x01 \x01(\x0b2\x13.edgir.lit.FloatLitH\x00\x12$\n\x07integer\x18\x02 \x01(\x0b2\x11.edgir.lit.IntLitH\x00\x12%\n\x07boolean\x18\x03 \x01(\x0b2\x12.edgir.lit.BoolLitH\x00\x12"\n\x04text\x18\x04 \x01(\x0b2\x12.edgir.lit.TextLitH\x00\x12&\n\x06struct\x18\t \x01(\x0b2\x14.edgir.lit.StructLitH\x00\x12$\n\x05range\x18\n \x01(\x0b2\x13.edgir.lit.RangeLitH\x00\x12$\n\x05array\x18\x0b \x01(\x0b2\x13.edgir.lit.ArrayLitH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x06\n\x04typeb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.lit_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.lit_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _STRUCTLIT_MEMBERSENTRY._options = None - _STRUCTLIT_MEMBERSENTRY._serialized_options = b"8\x01" + _STRUCTLIT_MEMBERSENTRY._serialized_options = b'8\x01' _FLOATLIT._serialized_start = 50 _FLOATLIT._serialized_end = 73 _INTLIT._serialized_start = 75 @@ -34,4 +29,4 @@ _ARRAYLIT._serialized_start = 369 _ARRAYLIT._serialized_end = 414 _VALUELIT._serialized_start = 417 - _VALUELIT._serialized_end = 743 + _VALUELIT._serialized_end = 743 \ No newline at end of file diff --git a/edg/edgir/lit_pb2.pyi b/edg/edgir/lit_pb2.pyi index 1ed644162..7d821ab3c 100644 --- a/edg/edgir/lit_pb2.pyi +++ b/edg/edgir/lit_pb2.pyi @@ -7,7 +7,6 @@ Package : edg.lit Literals for assorted priitive types, i.e fixed constant values. """ - from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor @@ -16,7 +15,6 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -28,16 +26,16 @@ class FloatLit(_message.Message): """* The core expression primitives we start with are the value literals that we can use """ - DESCRIPTOR: _descriptor.Descriptor VAL_FIELD_NUMBER: _builtins.int val: _builtins.float - def __init__(self, *, val: _builtins.float = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, val: _builtins.float=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___FloatLit: _TypeAlias = FloatLit @_typing.final @@ -46,11 +44,12 @@ class IntLit(_message.Message): VAL_FIELD_NUMBER: _builtins.int val: _builtins.int - def __init__(self, *, val: _builtins.int = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, val: _builtins.int=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___IntLit: _TypeAlias = IntLit @_typing.final @@ -59,11 +58,12 @@ class BoolLit(_message.Message): VAL_FIELD_NUMBER: _builtins.int val: _builtins.bool - def __init__(self, *, val: _builtins.bool = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, val: _builtins.bool=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___BoolLit: _TypeAlias = BoolLit @_typing.final @@ -72,11 +72,12 @@ class TextLit(_message.Message): VAL_FIELD_NUMBER: _builtins.int val: _builtins.str - def __init__(self, *, val: _builtins.str = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["val", b"val"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, val: _builtins.str=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['val', b'val'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___TextLit: _TypeAlias = TextLit @_typing.final @@ -86,17 +87,23 @@ class RangeLit(_message.Message): MAXIMUM_FIELD_NUMBER: _builtins.int @_builtins.property - def minimum(self) -> Global___ValueLit: ... + def minimum(self) -> Global___ValueLit: + ... + @_builtins.property - def maximum(self) -> Global___ValueLit: ... - def __init__(self, *, minimum: Global___ValueLit | None = ..., maximum: Global___ValueLit | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] + def maximum(self) -> Global___ValueLit: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["maximum", b"maximum", "minimum", b"minimum"] + def __init__(self, *, minimum: Global___ValueLit | None=..., maximum: Global___ValueLit | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['maximum', b'maximum', 'minimum', b'minimum'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___RangeLit: _TypeAlias = RangeLit @_typing.final @@ -111,24 +118,31 @@ class StructLit(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___ValueLit: ... - def __init__(self, *, key: _builtins.str = ..., value: Global___ValueLit | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> Global___ValueLit: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] + def __init__(self, *, key: _builtins.str=..., value: Global___ValueLit | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... MEMBERS_FIELD_NUMBER: _builtins.int @_builtins.property - def members(self) -> _containers.MessageMap[_builtins.str, Global___ValueLit]: ... - def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___ValueLit] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["members", b"members"] + def members(self) -> _containers.MessageMap[_builtins.str, Global___ValueLit]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___ValueLit] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['members', b'members'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___StructLit: _TypeAlias = StructLit @_typing.final @@ -137,12 +151,15 @@ class ArrayLit(_message.Message): ELTS_FIELD_NUMBER: _builtins.int @_builtins.property - def elts(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueLit]: ... - def __init__(self, *, elts: _abc.Iterable[Global___ValueLit] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["elts", b"elts"] + def elts(self) -> _containers.RepeatedCompositeFieldContainer[Global___ValueLit]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, elts: _abc.Iterable[Global___ValueLit] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['elts', b'elts'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ArrayLit: _TypeAlias = ArrayLit @_typing.final @@ -158,82 +175,50 @@ class ValueLit(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def floating(self) -> Global___FloatLit: ... + def floating(self) -> Global___FloatLit: + ... + @_builtins.property - def integer(self) -> Global___IntLit: ... + def integer(self) -> Global___IntLit: + ... + @_builtins.property - def boolean(self) -> Global___BoolLit: ... + def boolean(self) -> Global___BoolLit: + ... + @_builtins.property - def text(self) -> Global___TextLit: ... + def text(self) -> Global___TextLit: + ... + @_builtins.property - def struct(self) -> Global___StructLit: ... + def struct(self) -> Global___StructLit: + ... + @_builtins.property - def range(self) -> Global___RangeLit: ... + def range(self) -> Global___RangeLit: + ... + @_builtins.property - def array(self) -> Global___ArrayLit: ... + def array(self) -> Global___ArrayLit: + ... + @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - floating: Global___FloatLit | None = ..., - integer: Global___IntLit | None = ..., - boolean: Global___BoolLit | None = ..., - text: Global___TextLit | None = ..., - struct: Global___StructLit | None = ..., - range: Global___RangeLit | None = ..., - array: Global___ArrayLit | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "array", - b"array", - "boolean", - b"boolean", - "floating", - b"floating", - "integer", - b"integer", - "meta", - b"meta", - "range", - b"range", - "struct", - b"struct", - "text", - b"text", - "type", - b"type", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "array", - b"array", - "boolean", - b"boolean", - "floating", - b"floating", - "integer", - b"integer", - "meta", - b"meta", - "range", - b"range", - "struct", - b"struct", - "text", - b"text", - "type", - b"type", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal[ - "floating", "integer", "boolean", "text", "struct", "range", "array" - ] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... - -Global___ValueLit: _TypeAlias = ValueLit + def meta(self) -> _common_pb2.Metadata: + ... + + def __init__(self, *, floating: Global___FloatLit | None=..., integer: Global___IntLit | None=..., boolean: Global___BoolLit | None=..., text: Global___TextLit | None=..., struct: Global___StructLit | None=..., range: Global___RangeLit | None=..., array: Global___ArrayLit | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'struct', b'struct', 'text', b'text', 'type', b'type'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['array', b'array', 'boolean', b'boolean', 'floating', b'floating', 'integer', b'integer', 'meta', b'meta', 'range', b'range', 'struct', b'struct', 'text', b'text', 'type', b'type'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['floating', 'integer', 'boolean', 'text', 'struct', 'range', 'array'] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: + ... +Global___ValueLit: _TypeAlias = ValueLit \ No newline at end of file diff --git a/edg/edgir/name_pb2.py b/edg/edgir/name_pb2.py index 5d32702a7..1b64ac05f 100644 --- a/edg/edgir/name_pb2.py +++ b/edg/edgir/name_pb2.py @@ -1,21 +1,16 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x10edgir/name.proto\x12\nedgir.name\x1a\x12edgir/common.proto"O\n\tNamespace\x12\x0f\n\x05basic\x18\x01 \x01(\tH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x0b\n\tnamespace"A\n\x0bLibraryName\x12\x0c\n\x04name\x18\x02 \x01(\t\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgir/name.proto\x12\nedgir.name\x1a\x12edgir/common.proto"O\n\tNamespace\x12\x0f\n\x05basic\x18\x01 \x01(\tH\x00\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.MetadataB\x0b\n\tnamespace"A\n\x0bLibraryName\x12\x0c\n\x04name\x18\x02 \x01(\t\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadatab\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.name_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.name_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _NAMESPACE._serialized_start = 52 _NAMESPACE._serialized_end = 131 _LIBRARYNAME._serialized_start = 133 - _LIBRARYNAME._serialized_end = 198 + _LIBRARYNAME._serialized_end = 198 \ No newline at end of file diff --git a/edg/edgir/name_pb2.pyi b/edg/edgir/name_pb2.pyi index 5b30f799c..50564b2fe 100644 --- a/edg/edgir/name_pb2.pyi +++ b/edg/edgir/name_pb2.pyi @@ -10,14 +10,12 @@ There are three major classes of name in edg: - LocalNames, which help organize elements relative to each other. - LibraryNames, which we use to identify specific libraries. """ - from edgir import common_pb2 as _common_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -31,7 +29,6 @@ class Namespace(_message.Message): over items in the library. It lets us group elements in categories that are orthogonal to the usual Block, Port, Link, ontology. """ - DESCRIPTOR: _descriptor.Descriptor BASIC_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @@ -39,19 +36,24 @@ class Namespace(_message.Message): "* Basic namespaces are a way to organize library elements into a\n useful hirearchy (e.g. 'Core.*' for the most primitive definitions\n that we define, or 'NXP.*' for NXP made components.)\n\n Basic namespaces should have the following properties:\n\n - First char is a capital letter\n - All other chars must be letters, numbers, '-', '<', '>'\n - CamelCase is preffered, don't use any symbols in the name\n if possible.\n " @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__(self, *, basic: _builtins.str = ..., meta: _common_pb2.Metadata | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["basic", b"basic", "meta", b"meta", "namespace", b"namespace"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["basic", b"basic", "meta", b"meta", "namespace", b"namespace"] + def __init__(self, *, basic: _builtins.str=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['basic', b'basic', 'meta', b'meta', 'namespace', b'namespace'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_namespace: _TypeAlias = _typing.Literal["basic"] - _WhichOneofArgType_namespace: _TypeAlias = _typing.Literal["namespace", b"namespace"] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['basic', b'basic', 'meta', b'meta', 'namespace', b'namespace'] - def WhichOneof(self, oneof_group: _WhichOneofArgType_namespace) -> _WhichOneofReturnType_namespace | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_namespace: _TypeAlias = _typing.Literal['basic'] + _WhichOneofArgType_namespace: _TypeAlias = _typing.Literal['namespace', b'namespace'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_namespace) -> _WhichOneofReturnType_namespace | None: + ... Global___Namespace: _TypeAlias = Namespace @_typing.final @@ -61,7 +63,6 @@ class LibraryName(_message.Message): This can be the initial element in a path or reference. """ - DESCRIPTOR: _descriptor.Descriptor NAME_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @@ -69,13 +70,17 @@ class LibraryName(_message.Message): "* Since libraries allow for inheritance, we will often want to say\n this element, defined in *this* particular library.\n\n In those cases we want to be able to specify the relevant library\n by its identifier.\n\n Otherwise we assume it's somehow implicit which library we're\n talking about.\n " @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__(self, *, name: _builtins.str = ..., meta: _common_pb2.Metadata | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "name", b"name"] + def __init__(self, *, name: _builtins.str=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'name', b'name'] -Global___LibraryName: _TypeAlias = LibraryName + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... +Global___LibraryName: _TypeAlias = LibraryName \ No newline at end of file diff --git a/edg/edgir/ref_pb2.py b/edg/edgir/ref_pb2.py index ee4f3fd9c..154cb44fb 100644 --- a/edg/edgir/ref_pb2.py +++ b/edg/edgir/ref_pb2.py @@ -1,19 +1,14 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import name_pb2 as edgir_dot_name__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x0fedgir/ref.proto\x12\tedgir.ref\x1a\x12edgir/common.proto\x1a\x10edgir/name.proto"f\n\tLocalStep\x12-\n\x0ereserved_param\x18\x01 \x01(\x0e2\x13.edgir.ref.ReservedH\x00\x12\x12\n\x08allocate\x18\x02 \x01(\tH\x00\x12\x0e\n\x04name\x18\x03 \x01(\tH\x00B\x06\n\x04step"W\n\tLocalPath\x12#\n\x05steps\x18\x01 \x03(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata"\xa8\x01\n\x0bLibraryPath\x12&\n\x05start\x18\x01 \x01(\x0b2\x17.edgir.name.LibraryName\x12$\n\x05steps\x18\x02 \x03(\x0b2\x15.edgir.name.Namespace\x12$\n\x06target\x18\x03 \x01(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata*r\n\x08Reserved\x12\r\n\tUNDEFINED\x10\x00\x12\x12\n\x0eCONNECTED_LINK\x10\x01\x12\x10\n\x0cIS_CONNECTED\x10(\x12\n\n\x06LENGTH\x10*\x12\x08\n\x04NAME\x10,\x12\x0c\n\x08ELEMENTS\x10-\x12\r\n\tALLOCATED\x10.b\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0fedgir/ref.proto\x12\tedgir.ref\x1a\x12edgir/common.proto\x1a\x10edgir/name.proto"f\n\tLocalStep\x12-\n\x0ereserved_param\x18\x01 \x01(\x0e2\x13.edgir.ref.ReservedH\x00\x12\x12\n\x08allocate\x18\x02 \x01(\tH\x00\x12\x0e\n\x04name\x18\x03 \x01(\tH\x00B\x06\n\x04step"W\n\tLocalPath\x12#\n\x05steps\x18\x01 \x03(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata"\xa8\x01\n\x0bLibraryPath\x12&\n\x05start\x18\x01 \x01(\x0b2\x17.edgir.name.LibraryName\x12$\n\x05steps\x18\x02 \x03(\x0b2\x15.edgir.name.Namespace\x12$\n\x06target\x18\x03 \x01(\x0b2\x14.edgir.ref.LocalStep\x12%\n\x04meta\x18\xff\x01 \x01(\x0b2\x16.edgir.common.Metadata*r\n\x08Reserved\x12\r\n\tUNDEFINED\x10\x00\x12\x12\n\x0eCONNECTED_LINK\x10\x01\x12\x10\n\x0cIS_CONNECTED\x10(\x12\n\n\x06LENGTH\x10*\x12\x08\n\x04NAME\x10,\x12\x0c\n\x08ELEMENTS\x10-\x12\r\n\tALLOCATED\x10.b\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.ref_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.ref_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _RESERVED._serialized_start = 432 @@ -23,4 +18,4 @@ _LOCALPATH._serialized_start = 172 _LOCALPATH._serialized_end = 259 _LIBRARYPATH._serialized_start = 262 - _LIBRARYPATH._serialized_end = 430 + _LIBRARYPATH._serialized_end = 430 \ No newline at end of file diff --git a/edg/edgir/ref_pb2.pyi b/edg/edgir/ref_pb2.pyi index 992c4f924..4cb753aaf 100644 --- a/edg/edgir/ref_pb2.pyi +++ b/edg/edgir/ref_pb2.pyi @@ -11,7 +11,6 @@ referencing different elements in a designs or libraries. We enforce certain structural properties by having a series of nested 'steps' that determine the next step in a path reference. """ - from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import name_pb2 as _name_pb2 @@ -22,7 +21,6 @@ from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -30,42 +28,41 @@ else: DESCRIPTOR: _descriptor.FileDescriptor class _Reserved: - ValueType = _typing.NewType("ValueType", _builtins.int) + ValueType = _typing.NewType('ValueType', _builtins.int) V: _TypeAlias = ValueType class _ReservedEnumTypeWrapper(_enum_type_wrapper._EnumTypeWrapper[_Reserved.ValueType], _builtins.type): DESCRIPTOR: _descriptor.EnumDescriptor UNDEFINED: _Reserved.ValueType CONNECTED_LINK: _Reserved.ValueType - "* Directions we could move" + '* Directions we could move' IS_CONNECTED: _Reserved.ValueType - "* reserved parameters\n true implies CONNECTED_LINK resolves; not available on PortArray\n " + '* reserved parameters\n true implies CONNECTED_LINK resolves; not available on PortArray\n ' LENGTH: _Reserved.ValueType - " EXISTS = 41;\n available on PortArray and LinkArray\n " + ' EXISTS = 41;\n available on PortArray and LinkArray\n ' NAME: _Reserved.ValueType ELEMENTS: _Reserved.ValueType - "available on PortArray and LinkArray, returns a list of string of element names" + 'available on PortArray and LinkArray, returns a list of string of element names' ALLOCATED: _Reserved.ValueType - "cannot be used as a generator dependency\n available on PortArray, returns a list of string of incoming connection names,\n " + 'cannot be used as a generator dependency\n available on PortArray, returns a list of string of incoming connection names,\n ' class Reserved(_Reserved, metaclass=_ReservedEnumTypeWrapper): """* These are reserved terms that we'll end up using in various places. I'd rather have these in the block/link/bridges where they're going to exist, but that's not possible without polymorphism protibuf doesn't have """ - UNDEFINED: Reserved.ValueType CONNECTED_LINK: Reserved.ValueType -"* Directions we could move" +'* Directions we could move' IS_CONNECTED: Reserved.ValueType -"* reserved parameters\ntrue implies CONNECTED_LINK resolves; not available on PortArray\n" +'* reserved parameters\ntrue implies CONNECTED_LINK resolves; not available on PortArray\n' LENGTH: Reserved.ValueType -" EXISTS = 41;\navailable on PortArray and LinkArray\n" +' EXISTS = 41;\navailable on PortArray and LinkArray\n' NAME: Reserved.ValueType ELEMENTS: Reserved.ValueType -"available on PortArray and LinkArray, returns a list of string of element names" +'available on PortArray and LinkArray, returns a list of string of element names' ALLOCATED: Reserved.ValueType -"cannot be used as a generator dependency\navailable on PortArray, returns a list of string of incoming connection names,\n" +'cannot be used as a generator dependency\navailable on PortArray, returns a list of string of incoming connection names,\n' Global___Reserved: _TypeAlias = Reserved @_typing.final @@ -76,39 +73,31 @@ class LocalStep(_message.Message): The directions encode the type of thing we are referencing, but to the user all of these look just like local variables """ - DESCRIPTOR: _descriptor.Descriptor RESERVED_PARAM_FIELD_NUMBER: _builtins.int ALLOCATE_FIELD_NUMBER: _builtins.int NAME_FIELD_NUMBER: _builtins.int reserved_param: Global___Reserved.ValueType allocate: _builtins.str - "Allocates a new element in an array, valid for arrays only.\n Empty string means automatically allocated, while a non-empty string is a suggested name.\n " + 'Allocates a new element in an array, valid for arrays only.\n Empty string means automatically allocated, while a non-empty string is a suggested name.\n ' name: _builtins.str "*\n A local name is what something is called in the context of its parent,\n whether that parent is a namespace (as in the library) or some other\n element (as in a design or heirarchy block).\n\n localNames should have the following properties:\n\n - First char is a lower case letter\n - All other chars must be letters, numbers, '-', '<', '>'\n - lowerCamelCase is preffered, don't use any symbols in the name\n if possible.\n\n These are style guidelines, literally any string will work.\n " - def __init__( - self, - *, - reserved_param: Global___Reserved.ValueType = ..., - allocate: _builtins.str = ..., - name: _builtins.str = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "allocate", b"allocate", "name", b"name", "reserved_param", b"reserved_param", "step", b"step" - ] + def __init__(self, *, reserved_param: Global___Reserved.ValueType=..., allocate: _builtins.str=..., name: _builtins.str=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['allocate', b'allocate', 'name', b'name', 'reserved_param', b'reserved_param', 'step', b'step'] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "allocate", b"allocate", "name", b"name", "reserved_param", b"reserved_param", "step", b"step" - ] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['allocate', b'allocate', 'name', b'name', 'reserved_param', b'reserved_param', 'step', b'step'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_step: _TypeAlias = _typing.Literal["reserved_param", "allocate", "name"] - _WhichOneofArgType_step: _TypeAlias = _typing.Literal["step", b"step"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_step) -> _WhichOneofReturnType_step | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_step: _TypeAlias = _typing.Literal['reserved_param', 'allocate', 'name'] + _WhichOneofArgType_step: _TypeAlias = _typing.Literal['step', b'step'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_step) -> _WhichOneofReturnType_step | None: + ... Global___LocalStep: _TypeAlias = LocalStep @_typing.final @@ -116,25 +105,28 @@ class LocalPath(_message.Message): """* This is a path from a local context to some other local context. To be used as a reference. """ - DESCRIPTOR: _descriptor.Descriptor STEPS_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @_builtins.property - def steps(self) -> _containers.RepeatedCompositeFieldContainer[Global___LocalStep]: ... + def steps(self) -> _containers.RepeatedCompositeFieldContainer[Global___LocalStep]: + ... + @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, *, steps: _abc.Iterable[Global___LocalStep] | None = ..., meta: _common_pb2.Metadata | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta"] + def meta(self) -> _common_pb2.Metadata: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "steps", b"steps"] + def __init__(self, *, steps: _abc.Iterable[Global___LocalStep] | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'steps', b'steps'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___LocalPath: _TypeAlias = LocalPath @_typing.final @@ -142,7 +134,6 @@ class LibraryPath(_message.Message): """* This is a path to an element within a library from the root of a library. To be used as a way to reference such elements. """ - DESCRIPTOR: _descriptor.Descriptor START_FIELD_NUMBER: _builtins.int STEPS_FIELD_NUMBER: _builtins.int @@ -150,28 +141,29 @@ class LibraryPath(_message.Message): META_FIELD_NUMBER: _builtins.int @_builtins.property - def start(self) -> _name_pb2.LibraryName: ... + def start(self) -> _name_pb2.LibraryName: + ... + @_builtins.property - def steps(self) -> _containers.RepeatedCompositeFieldContainer[_name_pb2.Namespace]: ... + def steps(self) -> _containers.RepeatedCompositeFieldContainer[_name_pb2.Namespace]: + ... + @_builtins.property - def target(self) -> Global___LocalStep: ... + def target(self) -> Global___LocalStep: + ... + @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - start: _name_pb2.LibraryName | None = ..., - steps: _abc.Iterable[_name_pb2.Namespace] | None = ..., - target: Global___LocalStep | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["meta", b"meta", "start", b"start", "target", b"target"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "meta", b"meta", "start", b"start", "steps", b"steps", "target", b"target" - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - -Global___LibraryPath: _TypeAlias = LibraryPath + def meta(self) -> _common_pb2.Metadata: + ... + + def __init__(self, *, start: _name_pb2.LibraryName | None=..., steps: _abc.Iterable[_name_pb2.Namespace] | None=..., target: Global___LocalStep | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'start', b'start', 'target', b'target'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['meta', b'meta', 'start', b'start', 'steps', b'steps', 'target', b'target'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... +Global___LibraryPath: _TypeAlias = LibraryPath \ No newline at end of file diff --git a/edg/edgir/schema_pb2.py b/edg/edgir/schema_pb2.py index 515fd4516..46253e26c 100644 --- a/edg/edgir/schema_pb2.py +++ b/edg/edgir/schema_pb2.py @@ -1,23 +1,18 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import common_pb2 as edgir_dot_common__pb2 from ..edgir import elem_pb2 as edgir_dot_elem__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x12edgir/schema.proto\x12\x0cedgir.schema\x1a\x12edgir/common.proto\x1a\x10edgir/elem.proto"\xf5\x03\n\x07Library\x12*\n\x02id\x18\x01 \x01(\x0b2\x1e.edgir.schema.Library.LibIdent\x12\x0f\n\x07imports\x18\x02 \x03(\t\x12&\n\x04root\x18\n \x01(\x0b2\x18.edgir.schema.Library.NS\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a\xc4\x02\n\x02NS\x126\n\x07members\x18\x01 \x03(\x0b2%.edgir.schema.Library.NS.MembersEntry\x1a\xb7\x01\n\x03Val\x12 \n\x04port\x18\n \x01(\x0b2\x10.edgir.elem.PortH\x00\x125\n\x0fhierarchy_block\x18\r \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00\x12 \n\x04link\x18\x0e \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12-\n\tnamespace\x18\x14 \x01(\x0b2\x18.edgir.schema.Library.NSH\x00B\x06\n\x04type\x1aL\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12+\n\x05value\x18\x02 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val:\x028\x01\x1a\x18\n\x08LibIdent\x12\x0c\n\x04name\x18\x01 \x01(\t"6\n\x06Design\x12,\n\x08contents\x18\x02 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12edgir/schema.proto\x12\x0cedgir.schema\x1a\x12edgir/common.proto\x1a\x10edgir/elem.proto"\xf5\x03\n\x07Library\x12*\n\x02id\x18\x01 \x01(\x0b2\x1e.edgir.schema.Library.LibIdent\x12\x0f\n\x07imports\x18\x02 \x03(\t\x12&\n\x04root\x18\n \x01(\x0b2\x18.edgir.schema.Library.NS\x12$\n\x04meta\x18\x7f \x01(\x0b2\x16.edgir.common.Metadata\x1a\xc4\x02\n\x02NS\x126\n\x07members\x18\x01 \x03(\x0b2%.edgir.schema.Library.NS.MembersEntry\x1a\xb7\x01\n\x03Val\x12 \n\x04port\x18\n \x01(\x0b2\x10.edgir.elem.PortH\x00\x125\n\x0fhierarchy_block\x18\r \x01(\x0b2\x1a.edgir.elem.HierarchyBlockH\x00\x12 \n\x04link\x18\x0e \x01(\x0b2\x10.edgir.elem.LinkH\x00\x12-\n\tnamespace\x18\x14 \x01(\x0b2\x18.edgir.schema.Library.NSH\x00B\x06\n\x04type\x1aL\n\x0cMembersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12+\n\x05value\x18\x02 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val:\x028\x01\x1a\x18\n\x08LibIdent\x12\x0c\n\x04name\x18\x01 \x01(\t"6\n\x06Design\x12,\n\x08contents\x18\x02 \x01(\x0b2\x1a.edgir.elem.HierarchyBlockb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgir.schema_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgir.schema_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _LIBRARY_NS_MEMBERSENTRY._options = None - _LIBRARY_NS_MEMBERSENTRY._serialized_options = b"8\x01" + _LIBRARY_NS_MEMBERSENTRY._serialized_options = b'8\x01' _LIBRARY._serialized_start = 75 _LIBRARY._serialized_end = 576 _LIBRARY_NS._serialized_start = 226 @@ -29,4 +24,4 @@ _LIBRARY_LIBIDENT._serialized_start = 552 _LIBRARY_LIBIDENT._serialized_end = 576 _DESIGN._serialized_start = 578 - _DESIGN._serialized_end = 632 + _DESIGN._serialized_end = 632 \ No newline at end of file diff --git a/edg/edgir/schema_pb2.pyi b/edg/edgir/schema_pb2.pyi index 3080870ab..eeb7ebf64 100644 --- a/edg/edgir/schema_pb2.pyi +++ b/edg/edgir/schema_pb2.pyi @@ -8,7 +8,6 @@ Package : edg.schema These types contain the highest level data structures we use to describe sets of blocks, ports, and links. """ - from collections import abc as _abc from edgir import common_pb2 as _common_pb2 from edgir import elem_pb2 as _elem_pb2 @@ -18,7 +17,6 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -37,13 +35,11 @@ class Library(_message.Message): or definitional conflicts. This means that we can shuffle around partial libraries, for merging, modification, etc.. """ - DESCRIPTOR: _descriptor.Descriptor @_typing.final class NS(_message.Message): """* Library Namespace, avoiding collision w/ edg.name.Namespace""" - DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -55,53 +51,36 @@ class Library(_message.Message): NAMESPACE_FIELD_NUMBER: _builtins.int @_builtins.property - def port(self) -> _elem_pb2.Port: ... + def port(self) -> _elem_pb2.Port: + ... + @_builtins.property - def hierarchy_block(self) -> _elem_pb2.HierarchyBlock: ... + def hierarchy_block(self) -> _elem_pb2.HierarchyBlock: + ... + @_builtins.property - def link(self) -> _elem_pb2.Link: ... + def link(self) -> _elem_pb2.Link: + ... + @_builtins.property - def namespace(self) -> Global___Library.NS: ... - def __init__( - self, - *, - port: _elem_pb2.Port | None = ..., - hierarchy_block: _elem_pb2.HierarchyBlock | None = ..., - link: _elem_pb2.Link | None = ..., - namespace: Global___Library.NS | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "hierarchy_block", - b"hierarchy_block", - "link", - b"link", - "namespace", - b"namespace", - "port", - b"port", - "type", - b"type", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "hierarchy_block", - b"hierarchy_block", - "link", - b"link", - "namespace", - b"namespace", - "port", - b"port", - "type", - b"type", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_type: _TypeAlias = _typing.Literal["port", "hierarchy_block", "link", "namespace"] - _WhichOneofArgType_type: _TypeAlias = _typing.Literal["type", b"type"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: ... + def namespace(self) -> Global___Library.NS: + ... + + def __init__(self, *, port: _elem_pb2.Port | None=..., hierarchy_block: _elem_pb2.HierarchyBlock | None=..., link: _elem_pb2.Link | None=..., namespace: Global___Library.NS | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['hierarchy_block', b'hierarchy_block', 'link', b'link', 'namespace', b'namespace', 'port', b'port', 'type', b'type'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['hierarchy_block', b'hierarchy_block', 'link', b'link', 'namespace', b'namespace', 'port', b'port', 'type', b'type'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_type: _TypeAlias = _typing.Literal['port', 'hierarchy_block', 'link', 'namespace'] + _WhichOneofArgType_type: _TypeAlias = _typing.Literal['type', b'type'] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_type) -> _WhichOneofReturnType_type | None: + ... @_typing.final class MembersEntry(_message.Message): @@ -111,75 +90,83 @@ class Library(_message.Message): key: _builtins.str @_builtins.property - def value(self) -> Global___Library.NS.Val: ... - def __init__(self, *, key: _builtins.str = ..., value: Global___Library.NS.Val | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["value", b"value"] + def value(self) -> Global___Library.NS.Val: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] + def __init__(self, *, key: _builtins.str=..., value: Global___Library.NS.Val | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... MEMBERS_FIELD_NUMBER: _builtins.int @_builtins.property - def members(self) -> _containers.MessageMap[_builtins.str, Global___Library.NS.Val]: ... - def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___Library.NS.Val] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["members", b"members"] + def members(self) -> _containers.MessageMap[_builtins.str, Global___Library.NS.Val]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, members: _abc.Mapping[_builtins.str, Global___Library.NS.Val] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['members', b'members'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... @_typing.final class LibIdent(_message.Message): """* How we identify a library within a set. Will probably evolve to capture more metadata. """ - DESCRIPTOR: _descriptor.Descriptor NAME_FIELD_NUMBER: _builtins.int name: _builtins.str - def __init__(self, *, name: _builtins.str = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, name: _builtins.str=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... ID_FIELD_NUMBER: _builtins.int IMPORTS_FIELD_NUMBER: _builtins.int ROOT_FIELD_NUMBER: _builtins.int META_FIELD_NUMBER: _builtins.int @_builtins.property - def id(self) -> Global___Library.LibIdent: ... + def id(self) -> Global___Library.LibIdent: + ... + @_builtins.property - def imports(self) -> _containers.RepeatedScalarFieldContainer[_builtins.str]: ... + def imports(self) -> _containers.RepeatedScalarFieldContainer[_builtins.str]: + ... + @_builtins.property - def root(self) -> Global___Library.NS: ... + def root(self) -> Global___Library.NS: + ... + @_builtins.property - def meta(self) -> _common_pb2.Metadata: ... - def __init__( - self, - *, - id: Global___Library.LibIdent | None = ..., - imports: _abc.Iterable[_builtins.str] | None = ..., - root: Global___Library.NS | None = ..., - meta: _common_pb2.Metadata | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["id", b"id", "meta", b"meta", "root", b"root"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "id", b"id", "imports", b"imports", "meta", b"meta", "root", b"root" - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def meta(self) -> _common_pb2.Metadata: + ... + + def __init__(self, *, id: Global___Library.LibIdent | None=..., imports: _abc.Iterable[_builtins.str] | None=..., root: Global___Library.NS | None=..., meta: _common_pb2.Metadata | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['id', b'id', 'meta', b'meta', 'root', b'root'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['id', b'id', 'imports', b'imports', 'meta', b'meta', 'root', b'root'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___Library: _TypeAlias = Library @_typing.final class Design(_message.Message): """* This is a Design for an embedded system at some level of abstraction.""" - DESCRIPTOR: _descriptor.Descriptor CONTENTS_FIELD_NUMBER: _builtins.int @@ -187,12 +174,14 @@ class Design(_message.Message): def contents(self) -> _elem_pb2.HierarchyBlock: """* Delegate the actual contents of the design to a hierarchy block, for which ports are ignored""" - def __init__(self, *, contents: _elem_pb2.HierarchyBlock | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["contents", b"contents"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["contents", b"contents"] + def __init__(self, *, contents: _elem_pb2.HierarchyBlock | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['contents', b'contents'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['contents', b'contents'] -Global___Design: _TypeAlias = Design + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... +Global___Design: _TypeAlias = Design \ No newline at end of file diff --git a/edg/edgrpc/compiler_pb2.py b/edg/edgrpc/compiler_pb2.py index a72494fbd..235d99647 100644 --- a/edg/edgrpc/compiler_pb2.py +++ b/edg/edgrpc/compiler_pb2.py @@ -1,21 +1,16 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import schema_pb2 as edgir_dot_schema__pb2 from ..edgir import ref_pb2 as edgir_dot_ref__pb2 from ..edgir import lit_pb2 as edgir_dot_lit__pb2 from ..edgrpc import hdl_pb2 as edgrpc_dot_hdl__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x15edgrpc/compiler.proto\x12\x0fedgrpc.compiler\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x0fedgir/lit.proto\x1a\x10edgrpc/hdl.proto"^\n\x0bErrorRecord\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04kind\x18\x02 \x01(\t\x12\x0c\n\x04name\x18\x03 \x01(\t\x12\x0f\n\x07details\x18\x04 \x01(\t"e\n\x0fCompilerRequest\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"\xf2\x01\n\x0eCompilerResult\x12$\n\x06design\x18\x01 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x06errors\x18\x04 \x03(\x0b2\x1c.edgrpc.compiler.ErrorRecord\x12;\n\x0csolvedValues\x18\x02 \x03(\x0b2%.edgrpc.compiler.CompilerResult.Value\x1aO\n\x05Value\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLitb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15edgrpc/compiler.proto\x12\x0fedgrpc.compiler\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x0fedgir/lit.proto\x1a\x10edgrpc/hdl.proto"^\n\x0bErrorRecord\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0c\n\x04kind\x18\x02 \x01(\t\x12\x0c\n\x04name\x18\x03 \x01(\t\x12\x0f\n\x07details\x18\x04 \x01(\t"e\n\x0fCompilerRequest\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"\xf2\x01\n\x0eCompilerResult\x12$\n\x06design\x18\x01 \x01(\x0b2\x14.edgir.schema.Design\x12,\n\x06errors\x18\x04 \x03(\x0b2\x1c.edgrpc.compiler.ErrorRecord\x12;\n\x0csolvedValues\x18\x02 \x03(\x0b2%.edgrpc.compiler.CompilerResult.Value\x1aO\n\x05Value\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLitb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgrpc.compiler_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgrpc.compiler_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _ERRORRECORD._serialized_start = 114 @@ -25,4 +20,4 @@ _COMPILERRESULT._serialized_start = 314 _COMPILERRESULT._serialized_end = 556 _COMPILERRESULT_VALUE._serialized_start = 477 - _COMPILERRESULT_VALUE._serialized_end = 556 + _COMPILERRESULT_VALUE._serialized_end = 556 \ No newline at end of file diff --git a/edg/edgrpc/compiler_pb2.pyi b/edg/edgrpc/compiler_pb2.pyi index 88dd418b3..09f4d7453 100644 --- a/edg/edgrpc/compiler_pb2.pyi +++ b/edg/edgrpc/compiler_pb2.pyi @@ -6,7 +6,6 @@ Interface to the HDL (eg, library fetch) is not included here. This no longer uses gRPC to avoid complexity of sockets. """ - from collections import abc as _abc from edgir import lit_pb2 as _lit_pb2 from edgir import ref_pb2 as _ref_pb2 @@ -18,7 +17,6 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -33,33 +31,26 @@ class ErrorRecord(_message.Message): NAME_FIELD_NUMBER: _builtins.int DETAILS_FIELD_NUMBER: _builtins.int kind: _builtins.str - "kind of error, eg failed to generate" + 'kind of error, eg failed to generate' name: _builtins.str - "constraint name / short description" + 'constraint name / short description' details: _builtins.str - "longer description, optional" + 'longer description, optional' @_builtins.property def path(self) -> _ref_pb2.LocalPath: """link / block / port, cannot be the constraint""" - def __init__( - self, - *, - path: _ref_pb2.LocalPath | None = ..., - kind: _builtins.str = ..., - name: _builtins.str = ..., - details: _builtins.str = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "details", b"details", "kind", b"kind", "name", b"name", "path", b"path" - ] + def __init__(self, *, path: _ref_pb2.LocalPath | None=..., kind: _builtins.str=..., name: _builtins.str=..., details: _builtins.str=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['details', b'details', 'kind', b'kind', 'name', b'name', 'path', b'path'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ErrorRecord: _TypeAlias = ErrorRecord @_typing.final @@ -69,19 +60,23 @@ class CompilerRequest(_message.Message): REFINEMENTS_FIELD_NUMBER: _builtins.int @_builtins.property - def design(self) -> _schema_pb2.Design: ... + def design(self) -> _schema_pb2.Design: + ... + @_builtins.property - def refinements(self) -> _hdl_pb2.Refinements: ... - def __init__( - self, *, design: _schema_pb2.Design | None = ..., refinements: _hdl_pb2.Refinements | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["design", b"design", "refinements", b"refinements"] + def refinements(self) -> _hdl_pb2.Refinements: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["design", b"design", "refinements", b"refinements"] + def __init__(self, *, design: _schema_pb2.Design | None=..., refinements: _hdl_pb2.Refinements | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinements', b'refinements'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinements', b'refinements'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___CompilerRequest: _TypeAlias = CompilerRequest @_typing.final @@ -95,41 +90,47 @@ class CompilerResult(_message.Message): VALUE_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: ... + def path(self) -> _ref_pb2.LocalPath: + ... + @_builtins.property - def value(self) -> _lit_pb2.ValueLit: ... - def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., value: _lit_pb2.ValueLit | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] + def value(self) -> _lit_pb2.ValueLit: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] + def __init__(self, *, path: _ref_pb2.LocalPath | None=..., value: _lit_pb2.ValueLit | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... DESIGN_FIELD_NUMBER: _builtins.int ERRORS_FIELD_NUMBER: _builtins.int SOLVEDVALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def design(self) -> _schema_pb2.Design: ... + def design(self) -> _schema_pb2.Design: + ... + @_builtins.property - def errors(self) -> _containers.RepeatedCompositeFieldContainer[Global___ErrorRecord]: ... + def errors(self) -> _containers.RepeatedCompositeFieldContainer[Global___ErrorRecord]: + ... + @_builtins.property - def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___CompilerResult.Value]: ... - def __init__( - self, - *, - design: _schema_pb2.Design | None = ..., - errors: _abc.Iterable[Global___ErrorRecord] | None = ..., - solvedValues: _abc.Iterable[Global___CompilerResult.Value] | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["design", b"design"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "design", b"design", "errors", b"errors", "solvedValues", b"solvedValues" - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - -Global___CompilerResult: _TypeAlias = CompilerResult + def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___CompilerResult.Value]: + ... + + def __init__(self, *, design: _schema_pb2.Design | None=..., errors: _abc.Iterable[Global___ErrorRecord] | None=..., solvedValues: _abc.Iterable[Global___CompilerResult.Value] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['design', b'design'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'errors', b'errors', 'solvedValues', b'solvedValues'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... +Global___CompilerResult: _TypeAlias = CompilerResult \ No newline at end of file diff --git a/edg/edgrpc/hdl_pb2.py b/edg/edgrpc/hdl_pb2.py index 97b2a4a65..499d3c6e4 100644 --- a/edg/edgrpc/hdl_pb2.py +++ b/edg/edgrpc/hdl_pb2.py @@ -1,25 +1,20 @@ """Generated protocol buffer code.""" - from google.protobuf.internal import builder as _builder from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database - _sym_db = _symbol_database.Default() from ..edgir import schema_pb2 as edgir_dot_schema__pb2 from ..edgir import ref_pb2 as edgir_dot_ref__pb2 from ..edgir import elem_pb2 as edgir_dot_elem__pb2 from ..edgir import lit_pb2 as edgir_dot_lit__pb2 - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n\x10edgrpc/hdl.proto\x12\nedgrpc.hdl\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x10edgir/elem.proto\x1a\x0fedgir/lit.proto"\xb6\x04\n\x0bRefinements\x124\n\nsubclasses\x18\x01 \x03(\x0b2 .edgrpc.hdl.Refinements.Subclass\x12-\n\x06values\x18\x02 \x03(\x0b2\x1d.edgrpc.hdl.Refinements.Value\x1a\x8e\x01\n\x08Subclass\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12%\n\x03cls\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12+\n\x0breplacement\x18\x03 \x01(\x0b2\x16.edgir.ref.LibraryPathB\x08\n\x06source\x1a\xb0\x02\n\x05Value\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12A\n\tcls_param\x18\x02 \x01(\x0b2,.edgrpc.hdl.Refinements.Value.ClassParamPathH\x00\x12#\n\x04expr\x18\x03 \x01(\x0b2\x13.edgir.lit.ValueLitH\x01\x12%\n\x05param\x18\x04 \x01(\x0b2\x14.edgir.ref.LocalPathH\x01\x1a_\n\x0eClassParamPath\x12#\n\x03cls\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\nparam_path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPathB\x08\n\x06sourceB\x07\n\x05value"\x1a\n\nModuleName\x12\x0c\n\x04name\x18\x01 \x01(\t"8\n\rIndexResponse\x12\'\n\x07indexed\x18\x01 \x03(\x0b2\x16.edgir.ref.LibraryPath"9\n\x0eLibraryRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath"n\n\x0fLibraryResponse\x12-\n\x07element\x18\x01 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"S\n\tExprValue\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"b\n\x10GeneratorRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12%\n\x06values\x18\x04 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"B\n\x11GeneratorResponse\x12-\n\tgenerated\x18\x01 \x01(\x0b2\x1a.edgir.elem.HierarchyBlock"\x97\x01\n\x11RefinementRequest\x12/\n\x0frefinement_pass\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue">\n\x12RefinementResponse\x12(\n\tnewValues\x18\x01 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"\xfc\x01\n\x0eBackendRequest\x12\'\n\x07backend\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue\x12<\n\targuments\x18\x04 \x03(\x0b2).edgrpc.hdl.BackendRequest.ArgumentsEntry\x1a0\n\x0eArgumentsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x028\x01"\x8e\x01\n\x0fBackendResponse\x123\n\x07results\x18\x01 \x03(\x0b2".edgrpc.hdl.BackendResponse.Result\x1aF\n\x06Result\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0e\n\x04text\x18\x02 \x01(\tH\x00B\x08\n\x06result"1\n\rErrorResponse\x12\r\n\x05error\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x02 \x01(\t"\xc8\x02\n\nHdlRequest\x12.\n\x0cindex_module\x18\x01 \x01(\x0b2\x16.edgrpc.hdl.ModuleNameH\x00\x129\n\x13get_library_element\x18\x02 \x01(\x0b2\x1a.edgrpc.hdl.LibraryRequestH\x00\x12;\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1c.edgrpc.hdl.GeneratorRequestH\x00\x127\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1d.edgrpc.hdl.RefinementRequestH\x00\x121\n\x0brun_backend\x18\x04 \x01(\x0b2\x1a.edgrpc.hdl.BackendRequestH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00B\t\n\x07request"\xfd\x02\n\x0bHdlResponse\x121\n\x0cindex_module\x18\x01 \x01(\x0b2\x19.edgrpc.hdl.IndexResponseH\x00\x12:\n\x13get_library_element\x18\x02 \x01(\x0b2\x1b.edgrpc.hdl.LibraryResponseH\x00\x12<\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1d.edgrpc.hdl.GeneratorResponseH\x00\x128\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1e.edgrpc.hdl.RefinementResponseH\x00\x122\n\x0brun_backend\x18\x04 \x01(\x0b2\x1b.edgrpc.hdl.BackendResponseH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00\x12*\n\x05error\x18c \x01(\x0b2\x19.edgrpc.hdl.ErrorResponseH\x00B\n\n\x08responseb\x06proto3' -) +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10edgrpc/hdl.proto\x12\nedgrpc.hdl\x1a\x12edgir/schema.proto\x1a\x0fedgir/ref.proto\x1a\x10edgir/elem.proto\x1a\x0fedgir/lit.proto"\xb6\x04\n\x0bRefinements\x124\n\nsubclasses\x18\x01 \x03(\x0b2 .edgrpc.hdl.Refinements.Subclass\x12-\n\x06values\x18\x02 \x03(\x0b2\x1d.edgrpc.hdl.Refinements.Value\x1a\x8e\x01\n\x08Subclass\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12%\n\x03cls\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPathH\x00\x12+\n\x0breplacement\x18\x03 \x01(\x0b2\x16.edgir.ref.LibraryPathB\x08\n\x06source\x1a\xb0\x02\n\x05Value\x12$\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPathH\x00\x12A\n\tcls_param\x18\x02 \x01(\x0b2,.edgrpc.hdl.Refinements.Value.ClassParamPathH\x00\x12#\n\x04expr\x18\x03 \x01(\x0b2\x13.edgir.lit.ValueLitH\x01\x12%\n\x05param\x18\x04 \x01(\x0b2\x14.edgir.ref.LocalPathH\x01\x1a_\n\x0eClassParamPath\x12#\n\x03cls\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12(\n\nparam_path\x18\x02 \x01(\x0b2\x14.edgir.ref.LocalPathB\x08\n\x06sourceB\x07\n\x05value"\x1a\n\nModuleName\x12\x0c\n\x04name\x18\x01 \x01(\t"8\n\rIndexResponse\x12\'\n\x07indexed\x18\x01 \x03(\x0b2\x16.edgir.ref.LibraryPath"9\n\x0eLibraryRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath"n\n\x0fLibraryResponse\x12-\n\x07element\x18\x01 \x01(\x0b2\x1c.edgir.schema.Library.NS.Val\x12,\n\x0brefinements\x18\x03 \x01(\x0b2\x17.edgrpc.hdl.Refinements"S\n\tExprValue\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12"\n\x05value\x18\x02 \x01(\x0b2\x13.edgir.lit.ValueLit"b\n\x10GeneratorRequest\x12\'\n\x07element\x18\x02 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12%\n\x06values\x18\x04 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"B\n\x11GeneratorResponse\x12-\n\tgenerated\x18\x01 \x01(\x0b2\x1a.edgir.elem.HierarchyBlock"\x97\x01\n\x11RefinementRequest\x12/\n\x0frefinement_pass\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue">\n\x12RefinementResponse\x12(\n\tnewValues\x18\x01 \x03(\x0b2\x15.edgrpc.hdl.ExprValue"\xfc\x01\n\x0eBackendRequest\x12\'\n\x07backend\x18\x01 \x01(\x0b2\x16.edgir.ref.LibraryPath\x12$\n\x06design\x18\x02 \x01(\x0b2\x14.edgir.schema.Design\x12+\n\x0csolvedValues\x18\x03 \x03(\x0b2\x15.edgrpc.hdl.ExprValue\x12<\n\targuments\x18\x04 \x03(\x0b2).edgrpc.hdl.BackendRequest.ArgumentsEntry\x1a0\n\x0eArgumentsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x028\x01"\x8e\x01\n\x0fBackendResponse\x123\n\x07results\x18\x01 \x03(\x0b2".edgrpc.hdl.BackendResponse.Result\x1aF\n\x06Result\x12"\n\x04path\x18\x01 \x01(\x0b2\x14.edgir.ref.LocalPath\x12\x0e\n\x04text\x18\x02 \x01(\tH\x00B\x08\n\x06result"1\n\rErrorResponse\x12\r\n\x05error\x18\x01 \x01(\t\x12\x11\n\ttraceback\x18\x02 \x01(\t"\xc8\x02\n\nHdlRequest\x12.\n\x0cindex_module\x18\x01 \x01(\x0b2\x16.edgrpc.hdl.ModuleNameH\x00\x129\n\x13get_library_element\x18\x02 \x01(\x0b2\x1a.edgrpc.hdl.LibraryRequestH\x00\x12;\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1c.edgrpc.hdl.GeneratorRequestH\x00\x127\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1d.edgrpc.hdl.RefinementRequestH\x00\x121\n\x0brun_backend\x18\x04 \x01(\x0b2\x1a.edgrpc.hdl.BackendRequestH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00B\t\n\x07request"\xfd\x02\n\x0bHdlResponse\x121\n\x0cindex_module\x18\x01 \x01(\x0b2\x19.edgrpc.hdl.IndexResponseH\x00\x12:\n\x13get_library_element\x18\x02 \x01(\x0b2\x1b.edgrpc.hdl.LibraryResponseH\x00\x12<\n\x13elaborate_generator\x18\x03 \x01(\x0b2\x1d.edgrpc.hdl.GeneratorResponseH\x00\x128\n\x0erun_refinement\x18\x05 \x01(\x0b2\x1e.edgrpc.hdl.RefinementResponseH\x00\x122\n\x0brun_backend\x18\x04 \x01(\x0b2\x1b.edgrpc.hdl.BackendResponseH\x00\x12\x1b\n\x11get_proto_version\x18Z \x01(\rH\x00\x12*\n\x05error\x18c \x01(\x0b2\x19.edgrpc.hdl.ErrorResponseH\x00B\n\n\x08responseb\x06proto3') _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "edgrpc.hdl_pb2", globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'edgrpc.hdl_pb2', globals()) if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _BACKENDREQUEST_ARGUMENTSENTRY._options = None - _BACKENDREQUEST_ARGUMENTSENTRY._serialized_options = b"8\x01" + _BACKENDREQUEST_ARGUMENTSENTRY._serialized_options = b'8\x01' _REFINEMENTS._serialized_start = 105 _REFINEMENTS._serialized_end = 671 _REFINEMENTS_SUBCLASS._serialized_start = 222 @@ -59,4 +54,4 @@ _HDLREQUEST._serialized_start = 1853 _HDLREQUEST._serialized_end = 2181 _HDLRESPONSE._serialized_start = 2184 - _HDLRESPONSE._serialized_end = 2565 + _HDLRESPONSE._serialized_end = 2565 \ No newline at end of file diff --git a/edg/edgrpc/hdl_pb2.pyi b/edg/edgrpc/hdl_pb2.pyi index 6f22f752f..14ede7317 100644 --- a/edg/edgrpc/hdl_pb2.pyi +++ b/edg/edgrpc/hdl_pb2.pyi @@ -4,7 +4,6 @@ isort:skip_file * Defines messages for a service provided in Python that exposes HDL-to-edgir elaboration for a compiler in a different process / language. """ - from collections import abc as _abc from edgir import elem_pb2 as _elem_pb2 from edgir import lit_pb2 as _lit_pb2 @@ -16,7 +15,6 @@ from google.protobuf.internal import containers as _containers import builtins as _builtins import sys import typing as _typing - if sys.version_info >= (3, 10): from typing import TypeAlias as _TypeAlias else: @@ -35,32 +33,32 @@ class Refinements(_message.Message): REPLACEMENT_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: ... + def path(self) -> _ref_pb2.LocalPath: + ... + @_builtins.property - def cls(self) -> _ref_pb2.LibraryPath: ... + def cls(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property - def replacement(self) -> _ref_pb2.LibraryPath: ... - def __init__( - self, - *, - path: _ref_pb2.LocalPath | None = ..., - cls: _ref_pb2.LibraryPath | None = ..., - replacement: _ref_pb2.LibraryPath | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "cls", b"cls", "path", b"path", "replacement", b"replacement", "source", b"source" - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "cls", b"cls", "path", b"path", "replacement", b"replacement", "source", b"source" - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_source: _TypeAlias = _typing.Literal["path", "cls"] - _WhichOneofArgType_source: _TypeAlias = _typing.Literal["source", b"source"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: ... + def replacement(self) -> _ref_pb2.LibraryPath: + ... + + def __init__(self, *, path: _ref_pb2.LocalPath | None=..., cls: _ref_pb2.LibraryPath | None=..., replacement: _ref_pb2.LibraryPath | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'path', b'path', 'replacement', b'replacement', 'source', b'source'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'path', b'path', 'replacement', b'replacement', 'source', b'source'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_source: _TypeAlias = _typing.Literal['path', 'cls'] + _WhichOneofArgType_source: _TypeAlias = _typing.Literal['source', b'source'] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: + ... @_typing.final class Value(_message.Message): @@ -73,28 +71,36 @@ class Refinements(_message.Message): PARAM_PATH_FIELD_NUMBER: _builtins.int @_builtins.property - def cls(self) -> _ref_pb2.LibraryPath: ... + def cls(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property - def param_path(self) -> _ref_pb2.LocalPath: ... - def __init__( - self, *, cls: _ref_pb2.LibraryPath | None = ..., param_path: _ref_pb2.LocalPath | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["cls", b"cls", "param_path", b"param_path"] + def param_path(self) -> _ref_pb2.LocalPath: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["cls", b"cls", "param_path", b"param_path"] + def __init__(self, *, cls: _ref_pb2.LibraryPath | None=..., param_path: _ref_pb2.LocalPath | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'param_path', b'param_path'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['cls', b'cls', 'param_path', b'param_path'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... PATH_FIELD_NUMBER: _builtins.int CLS_PARAM_FIELD_NUMBER: _builtins.int EXPR_FIELD_NUMBER: _builtins.int PARAM_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: ... + def path(self) -> _ref_pb2.LocalPath: + ... + @_builtins.property - def cls_param(self) -> Global___Refinements.Value.ClassParamPath: ... + def cls_param(self) -> Global___Refinements.Value.ClassParamPath: + ... + @_builtins.property def expr(self) -> _lit_pb2.ValueLit: """set to a specific value""" @@ -103,73 +109,45 @@ class Refinements(_message.Message): def param(self) -> _ref_pb2.LocalPath: """set to a value of another parameter - invalid for classes for now""" - def __init__( - self, - *, - path: _ref_pb2.LocalPath | None = ..., - cls_param: Global___Refinements.Value.ClassParamPath | None = ..., - expr: _lit_pb2.ValueLit | None = ..., - param: _ref_pb2.LocalPath | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "cls_param", - b"cls_param", - "expr", - b"expr", - "param", - b"param", - "path", - b"path", - "source", - b"source", - "value", - b"value", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "cls_param", - b"cls_param", - "expr", - b"expr", - "param", - b"param", - "path", - b"path", - "source", - b"source", - "value", - b"value", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_source: _TypeAlias = _typing.Literal["path", "cls_param"] - _WhichOneofArgType_source: _TypeAlias = _typing.Literal["source", b"source"] - _WhichOneofReturnType_value: _TypeAlias = _typing.Literal["expr", "param"] - _WhichOneofArgType_value: _TypeAlias = _typing.Literal["value", b"value"] + def __init__(self, *, path: _ref_pb2.LocalPath | None=..., cls_param: Global___Refinements.Value.ClassParamPath | None=..., expr: _lit_pb2.ValueLit | None=..., param: _ref_pb2.LocalPath | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['cls_param', b'cls_param', 'expr', b'expr', 'param', b'param', 'path', b'path', 'source', b'source', 'value', b'value'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['cls_param', b'cls_param', 'expr', b'expr', 'param', b'param', 'path', b'path', 'source', b'source', 'value', b'value'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_source: _TypeAlias = _typing.Literal['path', 'cls_param'] + _WhichOneofArgType_source: _TypeAlias = _typing.Literal['source', b'source'] + _WhichOneofReturnType_value: _TypeAlias = _typing.Literal['expr', 'param'] + _WhichOneofArgType_value: _TypeAlias = _typing.Literal['value', b'value'] @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: ... - @_typing.overload - def WhichOneof(self, oneof_group: _WhichOneofArgType_value) -> _WhichOneofReturnType_value | None: ... + def WhichOneof(self, oneof_group: _WhichOneofArgType_source) -> _WhichOneofReturnType_source | None: + ... + @_typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType_value) -> _WhichOneofReturnType_value | None: + ... SUBCLASSES_FIELD_NUMBER: _builtins.int VALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def subclasses(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Subclass]: ... + def subclasses(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Subclass]: + ... + @_builtins.property - def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Value]: ... - def __init__( - self, - *, - subclasses: _abc.Iterable[Global___Refinements.Subclass] | None = ..., - values: _abc.Iterable[Global___Refinements.Value] | None = ..., - ) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["subclasses", b"subclasses", "values", b"values"] + def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___Refinements.Value]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, subclasses: _abc.Iterable[Global___Refinements.Subclass] | None=..., values: _abc.Iterable[Global___Refinements.Value] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['subclasses', b'subclasses', 'values', b'values'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___Refinements: _TypeAlias = Refinements @_typing.final @@ -178,11 +156,12 @@ class ModuleName(_message.Message): NAME_FIELD_NUMBER: _builtins.int name: _builtins.str - def __init__(self, *, name: _builtins.str = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["name", b"name"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, name: _builtins.str=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['name', b'name'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ModuleName: _TypeAlias = ModuleName @_typing.final @@ -191,12 +170,15 @@ class IndexResponse(_message.Message): INDEXED_FIELD_NUMBER: _builtins.int @_builtins.property - def indexed(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: ... - def __init__(self, *, indexed: _abc.Iterable[_ref_pb2.LibraryPath] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["indexed", b"indexed"] + def indexed(self) -> _containers.RepeatedCompositeFieldContainer[_ref_pb2.LibraryPath]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, indexed: _abc.Iterable[_ref_pb2.LibraryPath] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['indexed', b'indexed'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___IndexResponse: _TypeAlias = IndexResponse @_typing.final @@ -208,14 +190,16 @@ class LibraryRequest(_message.Message): def element(self) -> _ref_pb2.LibraryPath: """library element asked for""" - def __init__(self, *, element: _ref_pb2.LibraryPath | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["element", b"element"] + def __init__(self, *, element: _ref_pb2.LibraryPath | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['element', b'element'] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["element", b"element"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['element', b'element'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___LibraryRequest: _TypeAlias = LibraryRequest @_typing.final @@ -225,21 +209,23 @@ class LibraryResponse(_message.Message): REFINEMENTS_FIELD_NUMBER: _builtins.int @_builtins.property - def element(self) -> _schema_pb2.Library.NS.Val: ... + def element(self) -> _schema_pb2.Library.NS.Val: + ... + @_builtins.property def refinements(self) -> Global___Refinements: """only valid if element is a top-level block""" - def __init__( - self, *, element: _schema_pb2.Library.NS.Val | None = ..., refinements: Global___Refinements | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["element", b"element", "refinements", b"refinements"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["element", b"element", "refinements", b"refinements"] + def __init__(self, *, element: _schema_pb2.Library.NS.Val | None=..., refinements: Global___Refinements | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['element', b'element', 'refinements', b'refinements'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['element', b'element', 'refinements', b'refinements'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___LibraryResponse: _TypeAlias = LibraryResponse @_typing.final @@ -249,17 +235,23 @@ class ExprValue(_message.Message): VALUE_FIELD_NUMBER: _builtins.int @_builtins.property - def path(self) -> _ref_pb2.LocalPath: ... + def path(self) -> _ref_pb2.LocalPath: + ... + @_builtins.property - def value(self) -> _lit_pb2.ValueLit: ... - def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., value: _lit_pb2.ValueLit | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] + def value(self) -> _lit_pb2.ValueLit: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "value", b"value"] + def __init__(self, *, path: _ref_pb2.LocalPath | None=..., value: _lit_pb2.ValueLit | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ExprValue: _TypeAlias = ExprValue @_typing.final @@ -273,17 +265,19 @@ class GeneratorRequest(_message.Message): """path of library element containing the generator""" @_builtins.property - def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... - def __init__( - self, *, element: _ref_pb2.LibraryPath | None = ..., values: _abc.Iterable[Global___ExprValue] | None = ... - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["element", b"element"] + def values(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["element", b"element", "values", b"values"] + def __init__(self, *, element: _ref_pb2.LibraryPath | None=..., values: _abc.Iterable[Global___ExprValue] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['element', b'element'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['element', b'element', 'values', b'values'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___GeneratorRequest: _TypeAlias = GeneratorRequest @_typing.final @@ -292,15 +286,19 @@ class GeneratorResponse(_message.Message): GENERATED_FIELD_NUMBER: _builtins.int @_builtins.property - def generated(self) -> _elem_pb2.HierarchyBlock: ... - def __init__(self, *, generated: _elem_pb2.HierarchyBlock | None = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["generated", b"generated"] + def generated(self) -> _elem_pb2.HierarchyBlock: + ... - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["generated", b"generated"] + def __init__(self, *, generated: _elem_pb2.HierarchyBlock | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['generated', b'generated'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['generated', b'generated'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___GeneratorResponse: _TypeAlias = GeneratorResponse @_typing.final @@ -308,34 +306,33 @@ class RefinementRequest(_message.Message): """Runs a refinement pass - something that takes a full design and solved values and generates additional values, eg for refdes assignment """ - DESCRIPTOR: _descriptor.Descriptor REFINEMENT_PASS_FIELD_NUMBER: _builtins.int DESIGN_FIELD_NUMBER: _builtins.int SOLVEDVALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def refinement_pass(self) -> _ref_pb2.LibraryPath: ... + def refinement_pass(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property - def design(self) -> _schema_pb2.Design: ... + def design(self) -> _schema_pb2.Design: + ... + @_builtins.property - def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... - def __init__( - self, - *, - refinement_pass: _ref_pb2.LibraryPath | None = ..., - design: _schema_pb2.Design | None = ..., - solvedValues: _abc.Iterable[Global___ExprValue] | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["design", b"design", "refinement_pass", b"refinement_pass"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "design", b"design", "refinement_pass", b"refinement_pass", "solvedValues", b"solvedValues" - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: + ... + + def __init__(self, *, refinement_pass: _ref_pb2.LibraryPath | None=..., design: _schema_pb2.Design | None=..., solvedValues: _abc.Iterable[Global___ExprValue] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinement_pass', b'refinement_pass'] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['design', b'design', 'refinement_pass', b'refinement_pass', 'solvedValues', b'solvedValues'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___RefinementRequest: _TypeAlias = RefinementRequest @_typing.final @@ -344,12 +341,15 @@ class RefinementResponse(_message.Message): NEWVALUES_FIELD_NUMBER: _builtins.int @_builtins.property - def newValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... - def __init__(self, *, newValues: _abc.Iterable[Global___ExprValue] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["newValues", b"newValues"] + def newValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, newValues: _abc.Iterable[Global___ExprValue] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['newValues', b'newValues'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___RefinementResponse: _TypeAlias = RefinementResponse @_typing.final @@ -357,7 +357,6 @@ class BackendRequest(_message.Message): """Runs a backend - something that generates fabrication artifacts from a compiled design tree eg, generate KiCad netlist, or generate microcontroller firmware pinmap headers """ - DESCRIPTOR: _descriptor.Descriptor @_typing.final @@ -368,41 +367,43 @@ class BackendRequest(_message.Message): key: _builtins.str value: _builtins.str - def __init__(self, *, key: _builtins.str = ..., value: _builtins.str = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["key", b"key", "value", b"value"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, key: _builtins.str=..., value: _builtins.str=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['key', b'key', 'value', b'value'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... BACKEND_FIELD_NUMBER: _builtins.int DESIGN_FIELD_NUMBER: _builtins.int SOLVEDVALUES_FIELD_NUMBER: _builtins.int ARGUMENTS_FIELD_NUMBER: _builtins.int @_builtins.property - def backend(self) -> _ref_pb2.LibraryPath: ... + def backend(self) -> _ref_pb2.LibraryPath: + ... + @_builtins.property - def design(self) -> _schema_pb2.Design: ... + def design(self) -> _schema_pb2.Design: + ... + @_builtins.property - def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: ... + def solvedValues(self) -> _containers.RepeatedCompositeFieldContainer[Global___ExprValue]: + ... + @_builtins.property - def arguments(self) -> _containers.ScalarMap[_builtins.str, _builtins.str]: ... - def __init__( - self, - *, - backend: _ref_pb2.LibraryPath | None = ..., - design: _schema_pb2.Design | None = ..., - solvedValues: _abc.Iterable[Global___ExprValue] | None = ..., - arguments: _abc.Mapping[_builtins.str, _builtins.str] | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["backend", b"backend", "design", b"design"] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "arguments", b"arguments", "backend", b"backend", "design", b"design", "solvedValues", b"solvedValues" - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def arguments(self) -> _containers.ScalarMap[_builtins.str, _builtins.str]: + ... + + def __init__(self, *, backend: _ref_pb2.LibraryPath | None=..., design: _schema_pb2.Design | None=..., solvedValues: _abc.Iterable[Global___ExprValue] | None=..., arguments: _abc.Mapping[_builtins.str, _builtins.str] | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['backend', b'backend', 'design', b'design'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['arguments', b'arguments', 'backend', b'backend', 'design', b'design', 'solvedValues', b'solvedValues'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___BackendRequest: _TypeAlias = BackendRequest @_typing.final @@ -415,50 +416,56 @@ class BackendResponse(_message.Message): PATH_FIELD_NUMBER: _builtins.int TEXT_FIELD_NUMBER: _builtins.int text: _builtins.str - "for now, only text supported, for KiCad netlisting" + 'for now, only text supported, for KiCad netlisting' @_builtins.property def path(self) -> _ref_pb2.LocalPath: """path of corresponding element in design tree""" - def __init__(self, *, path: _ref_pb2.LocalPath | None = ..., text: _builtins.str = ...) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "result", b"result", "text", b"text"] + def __init__(self, *, path: _ref_pb2.LocalPath | None=..., text: _builtins.str=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'result', b'result', 'text', b'text'] - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["path", b"path", "result", b"result", "text", b"text"] + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['path', b'path', 'result', b'result', 'text', b'text'] - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_result: _TypeAlias = _typing.Literal["text"] - _WhichOneofArgType_result: _TypeAlias = _typing.Literal["result", b"result"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_result) -> _WhichOneofReturnType_result | None: ... + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_result: _TypeAlias = _typing.Literal['text'] + _WhichOneofArgType_result: _TypeAlias = _typing.Literal['result', b'result'] + def WhichOneof(self, oneof_group: _WhichOneofArgType_result) -> _WhichOneofReturnType_result | None: + ... RESULTS_FIELD_NUMBER: _builtins.int @_builtins.property - def results(self) -> _containers.RepeatedCompositeFieldContainer[Global___BackendResponse.Result]: ... - def __init__(self, *, results: _abc.Iterable[Global___BackendResponse.Result] | None = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["results", b"results"] + def results(self) -> _containers.RepeatedCompositeFieldContainer[Global___BackendResponse.Result]: + ... - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, results: _abc.Iterable[Global___BackendResponse.Result] | None=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['results', b'results'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___BackendResponse: _TypeAlias = BackendResponse @_typing.final class ErrorResponse(_message.Message): """catch all error response""" - DESCRIPTOR: _descriptor.Descriptor ERROR_FIELD_NUMBER: _builtins.int TRACEBACK_FIELD_NUMBER: _builtins.int error: _builtins.str traceback: _builtins.str - def __init__(self, *, error: _builtins.str = ..., traceback: _builtins.str = ...) -> None: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal["error", b"error", "traceback", b"traceback"] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + def __init__(self, *, error: _builtins.str=..., traceback: _builtins.str=...) -> None: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['error', b'error', 'traceback', b'traceback'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... Global___ErrorResponse: _TypeAlias = ErrorResponse @_typing.final @@ -471,7 +478,7 @@ class HdlRequest(_message.Message): RUN_BACKEND_FIELD_NUMBER: _builtins.int GET_PROTO_VERSION_FIELD_NUMBER: _builtins.int get_proto_version: _builtins.int - "no data" + 'no data' @_builtins.property def index_module(self) -> Global___ModuleName: @@ -486,67 +493,28 @@ class HdlRequest(_message.Message): """returns the elaborated IR""" @_builtins.property - def run_refinement(self) -> Global___RefinementRequest: ... + def run_refinement(self) -> Global___RefinementRequest: + ... + @_builtins.property - def run_backend(self) -> Global___BackendRequest: ... - def __init__( - self, - *, - index_module: Global___ModuleName | None = ..., - get_library_element: Global___LibraryRequest | None = ..., - elaborate_generator: Global___GeneratorRequest | None = ..., - run_refinement: Global___RefinementRequest | None = ..., - run_backend: Global___BackendRequest | None = ..., - get_proto_version: _builtins.int = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "elaborate_generator", - b"elaborate_generator", - "get_library_element", - b"get_library_element", - "get_proto_version", - b"get_proto_version", - "index_module", - b"index_module", - "request", - b"request", - "run_backend", - b"run_backend", - "run_refinement", - b"run_refinement", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "elaborate_generator", - b"elaborate_generator", - "get_library_element", - b"get_library_element", - "get_proto_version", - b"get_proto_version", - "index_module", - b"index_module", - "request", - b"request", - "run_backend", - b"run_backend", - "run_refinement", - b"run_refinement", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_request: _TypeAlias = _typing.Literal[ - "index_module", - "get_library_element", - "elaborate_generator", - "run_refinement", - "run_backend", - "get_proto_version", - ] - _WhichOneofArgType_request: _TypeAlias = _typing.Literal["request", b"request"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_request) -> _WhichOneofReturnType_request | None: ... + def run_backend(self) -> Global___BackendRequest: + ... + + def __init__(self, *, index_module: Global___ModuleName | None=..., get_library_element: Global___LibraryRequest | None=..., elaborate_generator: Global___GeneratorRequest | None=..., run_refinement: Global___RefinementRequest | None=..., run_backend: Global___BackendRequest | None=..., get_proto_version: _builtins.int=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'request', b'request', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'request', b'request', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_request: _TypeAlias = _typing.Literal['index_module', 'get_library_element', 'elaborate_generator', 'run_refinement', 'run_backend', 'get_proto_version'] + _WhichOneofArgType_request: _TypeAlias = _typing.Literal['request', b'request'] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_request) -> _WhichOneofReturnType_request | None: + ... Global___HdlRequest: _TypeAlias = HdlRequest @_typing.final @@ -566,77 +534,38 @@ class HdlResponse(_message.Message): """list of contained library elements""" @_builtins.property - def get_library_element(self) -> Global___LibraryResponse: ... + def get_library_element(self) -> Global___LibraryResponse: + ... + @_builtins.property - def elaborate_generator(self) -> Global___GeneratorResponse: ... + def elaborate_generator(self) -> Global___GeneratorResponse: + ... + @_builtins.property - def run_refinement(self) -> Global___RefinementResponse: ... + def run_refinement(self) -> Global___RefinementResponse: + ... + @_builtins.property - def run_backend(self) -> Global___BackendResponse: ... + def run_backend(self) -> Global___BackendResponse: + ... + @_builtins.property - def error(self) -> Global___ErrorResponse: ... - def __init__( - self, - *, - index_module: Global___IndexResponse | None = ..., - get_library_element: Global___LibraryResponse | None = ..., - elaborate_generator: Global___GeneratorResponse | None = ..., - run_refinement: Global___RefinementResponse | None = ..., - run_backend: Global___BackendResponse | None = ..., - get_proto_version: _builtins.int = ..., - error: Global___ErrorResponse | None = ..., - ) -> None: ... - _HasFieldArgType: _TypeAlias = _typing.Literal[ - "elaborate_generator", - b"elaborate_generator", - "error", - b"error", - "get_library_element", - b"get_library_element", - "get_proto_version", - b"get_proto_version", - "index_module", - b"index_module", - "response", - b"response", - "run_backend", - b"run_backend", - "run_refinement", - b"run_refinement", - ] - - def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ... - _ClearFieldArgType: _TypeAlias = _typing.Literal[ - "elaborate_generator", - b"elaborate_generator", - "error", - b"error", - "get_library_element", - b"get_library_element", - "get_proto_version", - b"get_proto_version", - "index_module", - b"index_module", - "response", - b"response", - "run_backend", - b"run_backend", - "run_refinement", - b"run_refinement", - ] - - def ClearField(self, field_name: _ClearFieldArgType) -> None: ... - _WhichOneofReturnType_response: _TypeAlias = _typing.Literal[ - "index_module", - "get_library_element", - "elaborate_generator", - "run_refinement", - "run_backend", - "get_proto_version", - "error", - ] - _WhichOneofArgType_response: _TypeAlias = _typing.Literal["response", b"response"] - - def WhichOneof(self, oneof_group: _WhichOneofArgType_response) -> _WhichOneofReturnType_response | None: ... - -Global___HdlResponse: _TypeAlias = HdlResponse + def error(self) -> Global___ErrorResponse: + ... + + def __init__(self, *, index_module: Global___IndexResponse | None=..., get_library_element: Global___LibraryResponse | None=..., elaborate_generator: Global___GeneratorResponse | None=..., run_refinement: Global___RefinementResponse | None=..., run_backend: Global___BackendResponse | None=..., get_proto_version: _builtins.int=..., error: Global___ErrorResponse | None=...) -> None: + ... + _HasFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'error', b'error', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'response', b'response', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] + + def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: + ... + _ClearFieldArgType: _TypeAlias = _typing.Literal['elaborate_generator', b'elaborate_generator', 'error', b'error', 'get_library_element', b'get_library_element', 'get_proto_version', b'get_proto_version', 'index_module', b'index_module', 'response', b'response', 'run_backend', b'run_backend', 'run_refinement', b'run_refinement'] + + def ClearField(self, field_name: _ClearFieldArgType) -> None: + ... + _WhichOneofReturnType_response: _TypeAlias = _typing.Literal['index_module', 'get_library_element', 'elaborate_generator', 'run_refinement', 'run_backend', 'get_proto_version', 'error'] + _WhichOneofArgType_response: _TypeAlias = _typing.Literal['response', b'response'] + + def WhichOneof(self, oneof_group: _WhichOneofArgType_response) -> _WhichOneofReturnType_response | None: + ... +Global___HdlResponse: _TypeAlias = HdlResponse \ No newline at end of file diff --git a/proto/edgir/expr.proto b/proto/edgir/expr.proto index 94080801c..80767e24a 100644 --- a/proto/edgir/expr.proto +++ b/proto/edgir/expr.proto @@ -283,6 +283,10 @@ message BinarySetExpr { // Concatenate : (lhs: String, rhss: Set[String]) -> Set[String] (prepend lhs to all elements) // : (lhss: Set[String], rhs: String) -> Set[String] (append rhs to all elements) CONCAT = 20; + + // Equality operator + // (lhss: Set[A], elt: A) -> Set[Bool] (pointwise equality of all elements in the set to the element) + EQ = 30; } Op op = 1; ValueExpr lhset = 2; From 9c3ca734361481e32066dcf92111934293ff88ea Mon Sep 17 00:00:00 2001 From: Richard Lin Date: Sun, 29 Mar 2026 21:38:05 -0700 Subject: [PATCH 09/21] kinda? working --- .../main/scala/edg/compiler/Compiler.scala | 2 +- edg/core/ArrayExpr.py | 8 ++++++++ edg/core/Binding.py | 4 +++- .../resources/edg-compiler-precompiled.jar | Bin 13120322 -> 13120321 bytes edg/hdl_server/__main__.py | 2 +- 5 files changed, 13 insertions(+), 3 deletions(-) diff --git a/compiler/src/main/scala/edg/compiler/Compiler.scala b/compiler/src/main/scala/edg/compiler/Compiler.scala index eb613cdd7..2d1114fe8 100644 --- a/compiler/src/main/scala/edg/compiler/Compiler.scala +++ b/compiler/src/main/scala/edg/compiler/Compiler.scala @@ -117,7 +117,7 @@ class AssignNamer() { } object Compiler { - final val kExpectedProtoVersion = 8 + final val kExpectedProtoVersion = 9 } /** Compiler for a particular design, with an associated library to elaborate references from. diff --git a/edg/core/ArrayExpr.py b/edg/core/ArrayExpr.py index d564508d1..6c5c221bd 100644 --- a/edg/core/ArrayExpr.py +++ b/edg/core/ArrayExpr.py @@ -128,6 +128,11 @@ def intersection(self) -> ArrayEltType: def hull(self) -> ArrayEltType: return self._create_unary_set_op(RangeSetOp.hull) + def elts_equals(self, other: ConstraintExpr[Any, None]) -> ArrayBoolExpr: + """Returns an ArrayBoolExpr of equality between each element of this and single-element other.""" + assert self._is_bound() and other._is_bound() + return ArrayBoolExpr()._new_bind(BinarySetOpBinding(self, other, EqOp.all_equal)) + ArrayBoolLike = Union["ArrayBoolExpr", Sequence[BoolLike]] @@ -135,6 +140,9 @@ def hull(self) -> ArrayEltType: class ArrayBoolExpr(ArrayExpr[BoolExpr, List[bool], ArrayBoolLike]): _elt_type = BoolExpr + def __invert__(self) -> ArrayBoolExpr: + return self._new_bind(UnarySetOpBinding(self, BoolOp.op_not)) + def any(self) -> BoolExpr: return BoolExpr()._new_bind(UnarySetOpBinding(self, BoolOp.op_or)) diff --git a/edg/core/Binding.py b/edg/core/Binding.py index 25d2f503f..62620bf06 100644 --- a/edg/core/Binding.py +++ b/edg/core/Binding.py @@ -314,6 +314,7 @@ def __init__(self, src: ConstraintExpr, op: Union[NumericOp, BoolOp, EqOp, Range NumericOp.sum: edgir.UnarySetExpr.SUM, BoolOp.op_and: edgir.UnarySetExpr.ALL_TRUE, BoolOp.op_or: edgir.UnarySetExpr.ANY_TRUE, + BoolOp.op_not: edgir.UnarySetExpr.NEGATE, EqOp.all_equal: edgir.UnarySetExpr.ALL_EQ, EqOp.all_unique: edgir.UnarySetExpr.ALL_UNIQUE, RangeSetOp.min: edgir.UnarySetExpr.MINIMUM, @@ -391,11 +392,12 @@ class BinarySetOpBinding(Binding): def __repr__(self) -> str: return f"BinaryOp({self.op}, ...)" - def __init__(self, lhset: ConstraintExpr, rhs: ConstraintExpr, op: NumericOp): + def __init__(self, lhset: ConstraintExpr, rhs: ConstraintExpr, op: Union[NumericOp, EqOp]): self.op_map = { # Numeric NumericOp.add: edgir.BinarySetExpr.ADD, NumericOp.mul: edgir.BinarySetExpr.MULT, + EqOp.all_equal: edgir.BinarySetExpr.EQ, } super().__init__() diff --git a/edg/core/resources/edg-compiler-precompiled.jar b/edg/core/resources/edg-compiler-precompiled.jar index 64d35124043e0901dc0ff9d336c5bd67249ee443..d9facb499d0069f9374d73a991dfc8b3c2685b61 100644 GIT binary patch delta 117671 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 delta 117577 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