zuspec-dataclasses 0.0.1.17421055506rc0__py3-none-any.whl → 0.0.1.18247373596rc0__py3-none-any.whl

zuspec/dataclasses/__init__.py

@@ -1,7 +1,22 @@
 
 
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 # from .activity_stmts import *
-from .decorators import dataclass, field, export, process, input, output, sync, const, port, export, bind
+from .decorators import dataclass, field, export, extern, process, input, output, sync, const, port, export, bind
 from .tlm import *
 # from .claims_refs import *
 # from .shared_stmts import *
@@ -9,9 +24,14 @@ from .tlm import *
 # from .core_lib import *
 # from vsc_dataclasses.expr import *
 
+from . import std
+
 from .bit import Bit
+from .action import Action
+from .std.clock_reset import ClockReset
 from .component import Component
-from .struct import Struct
+from .exec import ExecSync, Exec
+from .struct import Struct, ZuspecTypeBase
 from .ports import Input, Output, Port
 
 from asyncio import Event

zuspec/dataclasses/__version__.py

@@ -1,4 +1,19 @@
 
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 BASE="0.0.1"
-SUFFIX=".17421055506rc0"
+SUFFIX=".18247373596rc0"
 VERSION="%s%s" % (BASE, SUFFIX)

zuspec/dataclasses/action.py

@@ -1,3 +1,18 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 from typing import Self, Type, TypeVar
 from .decorators import dataclass, field
 from .component import Component

zuspec/dataclasses/addr_reg.py

@@ -1,61 +1,101 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 import abc
 import zuspec.dataclasses as zdc
-from typing import Annotated, TypeVar, Type, Union
+from typing import Annotated, Dict, TypeVar, Type, Union
 from .struct import StructPacked
 
+class AddrHandle(): pass
+
 class AddrTrait(zdc.Struct): pass
 
 
 class AddrSpaceBase:
     pass
 
-uint64_t = Annotated[int, "abc"]
+# uint64_t = Annotated[int, "abc"]
 
 AddrTraitT = TypeVar('AddrTraitT', bound=AddrTrait)
 
+@dataclass
 class AddrRegion[AddrTraitT]():
-    trait : Type[AddrTraitT] = zdc.trait()
-    pass
-
-class MyTrait(AddrTrait):
-    a : int = 5
+    trait : Type[AddrTraitT] = zdc.field()
 
+@dataclass
 class TransparentAddrSpace[AddrTraitT](AddrSpaceBase):
 
-    def add_region(self, region : AddrRegion[AddrTraitT]): pass
-
-    pass
-
-class MyAddrTrait(AddrTrait):
-    pass
-
-class Other(object):
-    pass
+    @abc.abstractmethod
+    def add_region(self, region : AddrRegion[AddrTraitT]) -> AddrHandle: 
+        """Adds a region to the address space, returning a handle to that region"""
+        pass
 
-t : TransparentAddrSpace = TransparentAddrSpace()
-o = Other()
+@dataclass
+class AddrClaim[AddrTraitT]():
+    trait : AddrTraitT = zdc.field(rand=True)
+    size : int = zdc.field(rand=True)
 
-r = AddrRegion[MyTrait]()
-r2 = AddrRegion[Other]()
+    @constraint
+    def size_align_c(self):
+        self.size > 0
 
-t.add_region(r2)
 
-r.trait.a
+    @abc.abstractmethod
+    def handle(self, offset : int = 0) -> AddrHandle:
+        """Returns a handle corresponding to the claim"""
+        pass
 
-RegT = TypeVar("RegT", bound=Union[int,StructPacked])
+RegT = TypeVar("RegT", bound=Union[BitVal,StructPacked])
 
 class Reg[RegT](object):
 
     @abc.abstractmethod
-    def read(self) -> Type[RegT]: pass
+    async def read(self) -> Type[RegT]:
+        """Reads the value of the register"""
+        pass
 
     @abc.abstractmethod
-    def write(self, data : Type[RegT]): pass
+    async def write(self, data : Type[RegT]): 
+        """Writes the value of the register"""
+        pass
+
+    def write_fields(self, fields : Dict[object,int]): pass
 
 class RegGroup(object):
     @abc.abstractmethod
-    def get_handle(self): pass
+    def get_handle(self) -> AddrHandle: 
+        """Gets the address handle that corresponds to this group"""
+        pass
 
     @abc.abstractmethod
-    def set_handle(self, h): pass
+    def set_handle(self, h): 
+        """Sets the address handle corresponding to this root group"""
+        pass
+
+
+class At(object):
+    a : zdc.Bit[15] = zdc.field()
+    b : zdc.Bit[15] = zdc.field()
+
+#    def __int__(self) -> int:
+#        pass
+
+# r : Reg[At] = 5
+# r.read() == 20
+# r.write()
+# r.write_fields({At.a : 5})
+# def reg(offset=)
 
+# def reg_array(offset=0, offset_of=lambda i: )

zuspec/dataclasses/annotation.py

@@ -1,3 +1,18 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 import dataclasses as dc
 from typing import Callable, ClassVar
 

zuspec/dataclasses/api/__init__.py

@@ -1,2 +1,18 @@
 
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
+from .type_processor import TypeProcessor
 from .visitor import Visitor

zuspec/dataclasses/api/type_processor.py

@@ -0,0 +1,26 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
+import abc
+
+class TypeProcessor(object):
+
+    @abc.abstractmethod
+    def new(self, c, *args, **kwargs):
+        pass
+
+    @abc.abstractmethod
+    def init(self, obj, *args, **kwargs):
+        pass

zuspec/dataclasses/api/visitor.py

@@ -1,14 +1,61 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 import dataclasses as dc
-from typing import Callable, ClassVar, Dict, Type
+import logging
+from dataclasses import Field, MISSING
+from typing import Callable, ClassVar, Dict, Type, List, Tuple
 from ..annotation import Annotation
+from ..bit import Bit
 from ..component import Component
+from ..exec import Exec, ExecKind, ExecSync
 from ..ports import Input, Output
-from ..struct import Struct
+from ..struct import Extern, Struct
+import inspect
+import ast
+import textwrap
+
+class _BindPathMock:
+    def __init__(self, typ, path=None):
+        self._typ = typ
+        self._path = path or []
+
+    def __getattribute__(self, name):
+        if name in ("_typ", "_path", "__class__"):
+            return object.__getattribute__(self, name)
+        # Validate field exists
+        fields = {f.name for f in dc.fields(self._typ)}
+        if name not in fields:
+            raise AttributeError(f"Invalid field '{name}' in path {'.'.join(self._path + [name])}")
+        # Get field type
+        field_type = next(f.type for f in dc.fields(self._typ) if f.name == name)
+        # Return new mock for nested access
+        return _BindPathMock(field_type, self._path + [name])
+
+    def __call__(self):
+        # For supporting callables if needed
+        return self
+
+    def __repr__(self):
+        return f"_BindPathMock({self._typ}, {self._path})"
 
 @dc.dataclass
 class Visitor(object):
     _type_m : Dict[Type,Callable] = dc.field(default_factory=dict)
     _field_factory_m : Dict[Type,Callable] = dc.field(default_factory=dict)
+    _log : ClassVar = logging.getLogger("Visitor")
 
     def __post_init__(self):
         self._type_m = {
@@ -20,41 +67,274 @@ class Visitor(object):
         }
 
     def visit(self, t):
+        # Accept both class and instance
+        t_cls = t if isinstance(t, type) else type(t)
         found = False
         for base_t,method in self._type_m.items():
-            if issubclass(t, base_t):
+            if issubclass(t_cls, base_t):
                 method(t)
                 found = True
                 break
         if not found:
-            raise Exception("Unsupported class %s" % str(type(t)))
+            raise Exception("Unsupported class %s" % str(t))
 
     def visitComponentType(self, t):
-        self.visitStructType(t)
+        # Always work with the class, not the instance
+        t_cls = t if isinstance(t, type) else type(t)
+        self.visitStructType(t_cls)
         pass
 
-    def visitStructType(self, t : Struct):
+    def _elabBindPath(self, path_lambda, root_type):
+        """
+        Processes a lambda expression returning a single property path.
+        Returns: (field_obj, path_tuple)
+        """
+        root_mock = _BindPathMock(root_type, ["s"])
+        result_mock = path_lambda(root_mock)
+        path = getattr(result_mock, "_path", None)
+        if path is None:
+            raise ValueError("Lambda must return a _BindPathMock instance")
+        typ = root_type
+        for name in path[1:]:  # skip 's'
+            field = next(f for f in dc.fields(typ) if f.name == name)
+            typ = field.type
+        return (field, tuple(path))
+
+    def _elabBinds(self, bind_lambda, root_type):
+        # Instantiate mock for root
+        root_mock = _BindPathMock(root_type, ["s"])
+        # Evaluate lambda to get mapping
+        mapping = bind_lambda(root_mock)
+        result = {}
+        for k, v in mapping.items():
+            # Extract path from mock objects
+            k_path = getattr(k, "_path", None)
+            v_path = getattr(v, "_path", None)
+            if k_path is None or v_path is None:
+                raise ValueError("Bind keys/values must be _BindPathMock instances")
+            # Get terminal Field for key
+            k_typ = root_type
+            for name in k_path[1:]:  # skip 's'
+                field = next(f for f in dc.fields(k_typ) if f.name == name)
+                k_typ = field.type
+            k_field = field
+            # Get terminal Field for value
+            v_typ = root_type
+            for name in v_path[1:]:
+                field = next(f for f in dc.fields(v_typ) if f.name == name)
+                v_typ = field.type
+            v_field = field
+            result[(k_field, tuple(k_path))] = (v_field, tuple(v_path))
+        return result
+
+    def _visitFields(self, t : Struct):
+        print("--> visitFields")
         for f in dc.fields(t):
+            print("Field: %s" % f.name)
             self._dispatchField(f)
+
+    def _dispatchField(self, f : dc.Field):
+        if f.default_factory not in (None, dc.MISSING):
+            if issubclass(f.default_factory, Input):
+                self.visitFieldInOut(f, False)
+            elif issubclass(f.default_factory, Output):
+                self.visitFieldInOut(f, True)
+            elif issubclass(f.default_factory, Exec):
+                self.visitExec(f)
+            elif issubclass(f.default_factory, Extern):
+                self.visitFieldExtern(f)
+            else:
+                raise Exception("Unknown factory %s" % f.default_factory)
+            pass
+        elif f.type in (str, int, float):
+            self.visitFieldData(f)
+        elif issubclass(f.type, Component):
+            print("visitFieldClass: Component %s" % f, flush=True)
+            self.visitFieldClass(f)
+        else:
+            print("visitFieldClass: %s" % f, flush=True)
+            self.visitFieldClass(f)
+
+    def _visitExecs(self, t):
+        exec_t = (
+            (ExecSync, self.visitExecSync),
+            (Exec, self.visitExec)
+        )
+        for n in dir(t):
+            o = getattr(t, n)
+            for et, em in exec_t:
+                if isinstance(o, et):
+                    em(o)
+                    break
+
+    def _visitFunctions(self, t):
+        for e in dir(t):
+            if not e.startswith("__") and callable(getattr(t, e)):
+                print("Function: %s" % e)
+                self.visitFunction(getattr(t, e))
+
+    def visitFunction(self, f):
+        pass
+
+    def _visitDataType(self, t):
+
+        if t == int:
+            self.visitDataTypeInt()
+        elif type(t) is type:
+            zsp_base_t = (
+                (Component, self.visitDataTypeComponent),
+            )
+
+            v = None
+            for tt,vv in zsp_base_t:
+                print("t: %s tt: %s vv: %s" % (t, tt, vv))
+                if issubclass(t, tt):
+                    v = vv
+                    break
+            
+            v(t)
+        else:
+            raise Exception("Unknown type %s" % str(t))
+        pass
+
+    def visitDataTypeComponent(self, t):
+        pass
+
+    def visitDataTypeInt(self):
+        pass
+
+    def visitField(self, f : dc.Field):
+        pass
+
+    def visitFieldClass(self, f : dc.Field):
+        self.visitField(f)
+
+    def visitFieldInOut(self, f : dc.Field, is_out : bool):
+        self.visitField(f)
+
+    def visitFieldData(self, f : dc.Field):
+        self.visitField(f)
+        self._visitDataType(f.type)
+
+    def visitStructType(self, t : Struct):
+        self._visitFields(t)
+        self._visitExecs(t)
         
         for f in dir(t):
             o = getattr(t, f)
-            if callable(o) and hasattr(o, Annotation.NAME):
-                self.visitExec(f, o)
-                print("Found")
+#             if callable(o) and hasattr(o, Annotation.NAME):
+#                 # Extract source code of the method
+#                 try:
+#                     src = inspect.getsource(o)
+#                     src = textwrap.dedent(src)
+#                     tree = ast.parse(src)
+#                     for stmt in tree.body[0].body:  # tree.body[0] is the FunctionDef
+#                         self.visit_statement(stmt)
+#                 except Exception as e:
+#                     print(f"Could not process method {f}: {e}")
+# #                self.visitExec(f, o)
+# #                print("Found")
+
+    def _findFieldRefs(self, t : Struct, method) -> List[Tuple[bool,dc.Field,Tuple[str]]]:
+        """
+        Processes the body of a Python method to identify class members
+        referenced inside. 
+        Returns: List of [<is_write>,[path]]
+        """
+        import inspect, ast, textwrap
+
+        src = inspect.getsource(method)
+        src = textwrap.dedent(src)
+        tree = ast.parse(src)
+        refs = []
+
+        # Map field names to Field objects
+        field_map = {f.name: f for f in dc.fields(t)}
+
+        class FieldRefVisitor(ast.NodeVisitor):
+            def __init__(self):
+                self.refs = []
+
+            def visit_Assign(self, node):
+                # Left-hand side: writes
+                for target in node.targets:
+                    if isinstance(target, ast.Attribute) and isinstance(target.value, ast.Name) and target.value.id == "self":
+                        field = target.attr
+                        if field in field_map:
+                            self.refs.append((True, field_map[field], ("self", field)))
+                # Right-hand side: reads
+                self.visit(node.value)
+
+            def visit_Attribute(self, node):
+                if isinstance(node.value, ast.Name) and node.value.id == "self":
+                    field = node.attr
+                    if field in field_map:
+                        self.refs.append((False, field_map[field], ("self", field)))
+                self.generic_visit(node)
+
+        visitor = FieldRefVisitor()
+        for stmt in tree.body[0].body:
+            visitor.visit(stmt)
+
+        # Remove duplicate refs (e.g., multiple reads/writes)
+        unique_refs = []
+        seen = set()
+        for ref in visitor.refs:
+            key = (ref[0], ref[1].name, ref[2])
+            if key not in seen:
+                unique_refs.append(ref)
+                seen.add(key)
+        return unique_refs
 
-    def visitExec(self, name, m):
+    def visitExec(self, e : Exec):
         pass
 
-    def _dispatchField(self, f : dc.Field):
-        if f.default_factory in self._field_factory_m.keys():
-            self._field_factory_m[f.default_factory](f)
-        else:
-            self.visitField(f)
+    def visitExecSync(self, e : ExecSync):
+        self.visitExec(e)
 
-    def visitField(self, f : dc.Field):
+    def visitFieldExtern(self, f : dc.Field):
         pass
 
+    def visitOutputField(self, f : dc.Field):
+        self.visitField(f)
+
+    def visitIntField(self, f : dc.Field):
+        self.visitField(f)
+
+    def visitStrField(self, f : dc.Field):
+        self.visitField(f)
+
+    def visit_statement(self, stmt):
+        method = f"visit_{type(stmt).__name__}"
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(stmt)
+
+    def generic_visit(self, stmt):
+        # Recursively visit child statements if present
+        for field, value in ast.iter_fields(stmt):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ast.stmt):
+                        self.visit_statement(item)
+            elif isinstance(value, ast.stmt):
+                self.visit_statement(value)
+
+    def visit_Assign(self, stmt: ast.Assign):
+        # Example: handle assignment statements
+        # Recursively visit child nodes if needed
+        self.generic_visit(stmt)
+
+    def visit_If(self, stmt: ast.If):
+        # Example: handle if statements
+        for s in stmt.body:
+            self.visit_statement(s)
+        for s in stmt.orelse:
+            self.visit_statement(s)
+
+    def visit_Expr(self, stmt: ast.Expr):
+        # Example: handle expression statements
+        self.generic_visit(stmt)
+
     def visitInput(self, f : dc.Field):
         self.visitField(f)
         pass

zuspec/dataclasses/bit.py

@@ -1,7 +1,12 @@
 import dataclasses as dc
-from typing import Dict
+from typing import Dict, Generic, TypeVar, Literal, Type
 
 class BitMeta(type):
+    """
+    The BitMeta class is a constructor for Bit types.
+    Bit[12], for example, produces a Bit type where
+    W=12.
+    """
 
     def __new__(cls, name, bases, attrs):
         return super().__new__(cls, name, bases, attrs)
@@ -15,12 +20,19 @@ class BitMeta(type):
             return self.type_m[W]
         else:
             t = type("bit[%d]" % W, (Bit,), {
-                "T" : W
+                "W" : W
             })
             self.type_m[W] = t
             return t
 
-
 class Bit(metaclass=BitMeta):
-    T : int = 1
-    pass
+    """
+    Variables of 'Bit' type represent unsigned W-bit values.
+    The value of the variables is automatically masked. For 
+    example, assigning 20 (b10100) to a 4-bit variable will 
+    result in 4 (b0100) being stored in the variable.
+    """
+    W : int = 1
+
+class Bits(metaclass=BitMeta):
+    W : int = -1

zuspec/dataclasses/bundle.py

@@ -1,3 +1,18 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 from typing import Annotated, Type, TypeVar
 from .decorators import dataclass
 
@@ -11,6 +26,8 @@ class Bundle(object):
     fields are created with mirror() or field(mirror=True)
 
     A bundle field can be connected to a mirror field. 
+    A bundle monitor field can be connected to both a 
+    bundle and a bundle mirror.
     - Bundle
     - Bundle Mirror
     - Bundle Monitor (all are inputs / exports)

zuspec/dataclasses/component.py

@@ -1,6 +1,26 @@
-from .decorators import dataclass
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
+import abc
+from typing import TYPE_CHECKING
+from .decorators import dataclass, field
 from .struct import Struct
 
+if TYPE_CHECKING:
+    from .std.timebase import TimeBase
+
 @dataclass
 class Component(Struct):
     """
@@ -9,7 +29,34 @@ class Component(Struct):
     - The root component and fields of component type are constructed
     - The 'init_down' method is invoked in a depth-first manner
     - The 'init_up' method is invoked
+
+    A Component class supports the following decorated methods:
+    - sync
+    - constraint
+    - activity
     """
+#    def build(self): pass
+
+    @abc.abstractmethod
+    async def wait(self, amt : float, units):
+        """
+        Uses the default timebase to suspend execution of the
+        calling coroutine for the specified time.
+        """
+        pass
 
-    def build(self): pass
+    @abc.abstractmethod
+    async def wait_next(self, count : int = 1):
+        """
+        Uses the default timebase to suspend execution of the
+        calling coroutine for the specified number of domain
+        evaluation events (eg clock cycles).
+        """
+        pass
 
+@dataclass
+class ComponentExtern(Component):
+    """
+    Extern components are used to interface with existing descriptions,
+    such as existing Verilog RTL.
+    """

zuspec/dataclasses/decorators.py

@@ -1,31 +1,60 @@
-'''
-Created on Mar 19, 2022
-
-@author: mballance
-'''
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Created on Mar 19, 2022
+# @author: mballance
+#****************************************************************************
 import dataclasses
 import dataclasses as dc
-from typing import Any, Callable, Dict, Self, TypeVar
-# from vsc_dataclasses.decorators import *
-# from .impl.action_decorator_impl import ActionDecoratorImpl
-# from .impl.exec_decorator_impl import ExecDecoratorImpl
-# from .impl.exec_kind_e import ExecKindE
-# from .impl.extend_kind_e import ExtendKindE
-# from .impl.extend_decorator_impl import ExtendDecoratorImpl
-# from .impl.extend_action_decorator_impl import ExtendActionDecoratorImpl
-# from .impl.extend_component_decorator_impl import ExtendComponentDecoratorImpl
-# from .impl.fn_decorator_impl import FnDecoratorImpl
-# from .impl.struct_decorator_impl import StructDecoratorImpl
-# from .impl.struct_kind_e import StructKindE
-# from .impl.component_decorator_impl import ComponentDecoratorImpl
-# from .impl.activity_decorator_impl import ActivityDecoratorImpl
-# from .impl.type_kind_e import TypeKindE
+import enum
+import inspect
+import typing
+from typing import Any, Callable, Dict, Optional, Self, TypeVar, TYPE_CHECKING, Union
 from .annotation import Annotation, AnnotationSync
-from .ports import Input, Output
-from .clock import Clock
+
+
+if TYPE_CHECKING:
+    from .api.type_processor import TypeProcessor
 
 def dataclass(cls, **kwargs):
-    return dc.dataclass(cls, **kwargs)
+    # TODO: Add type annotations to decorated methods
+    cls_annotations = cls.__annotations__
+
+    for name, value in cls.__dict__.items():
+#        print("Name: %s ; Value: %s" % (name, value))
+        if isinstance(value, dc.Field) and not name in cls_annotations:
+            print("TODO: annotate field")
+            cls_annotations[name] = int
+
+    cls_t = dc.dataclass(cls, **kwargs)
+
+    setattr(cls_t, "__base_init__", getattr(cls_t, "__init__"))
+    def local_init(self, tp : 'TypeProcessor', *args, **kwargs):
+        """Only called during type processing"""
+        return tp.init(self, *args, **kwargs)
+    setattr(cls_t, "__init__", local_init)
+
+    if not hasattr(cls_t, "__base_new__"):
+        setattr(cls_t, "__base_new__", getattr(cls_t, "__new__"))
+        def local_new(c, tp : 'TypeProcessor', *args, **kwargs):
+            """Always called during user-object construction"""
+            return tp.new(c, *args, **kwargs)
+        setattr(cls_t, "__new__", local_new)
+
+
+    return cls_t
 
 def bundle():
     return dc.field()
@@ -94,8 +123,9 @@ def always(instr : BitLiteral):
 a = bit(20)[3:4] 
 
 SelfT = TypeVar('SelfT')
+T = TypeVar('T')
 
-class bind[T](object):
+class bind[T]:
     def __init__(self, c : Callable[[T],Dict[Any,Any]]):
         self._c = c
     def __call__(self, s) -> Dict[Any,Any]:
@@ -103,8 +133,49 @@ class bind[T](object):
     
 #a = bind2(lambda s:{s.}, selfT=Self)
 
-def field(rand=False, bind : Callable[[object],Dict[Any,Any]] = None):
-    pass
+def field(
+        rand=False, 
+        bind : Optional[Callable[[object],Dict[Any,Any]]] = None,
+        init : Optional[Union[Dict[str,Any], Callable[[object],Dict[Any,Any]]]] = None,
+        default_factory : Optional[Any] = None,
+        default : Optional[Any] = None):
+    args = {}
+    metadata = None
+
+#     # Obtain the location of this call
+#     import inspect
+#     frame = inspect.currentframe()
+#     print("--> ")
+#     while frame is not None:
+#         modname = frame.f_globals["__name__"]
+
+#         print("modname: %s" % modname)
+#         if not modname.startswith("zuspec.dataclasses") and not modname.startswith("importlib"):
+#             break
+# #            pass
+# #            frame = frame.f_back
+#         else:
+#             frame = frame.f_back
+#     print("<-- ")
+
+#     if frame is not None:
+#         print("Location: %s:%d" % (frame.f_code.co_filename, frame.f_lineno))
+
+    if default_factory is not None:
+        args["default_factory"] = default_factory
+
+    if bind is not None:
+        metadata = {} if metadata is None else metadata
+        metadata["bind"] = bind
+
+    # *Always* specify a default to avoid becoming a required field
+    if "default_factory" not in args.keys():
+        args["default"] = default
+
+    if metadata is not None:
+        print("metadata: %s" % metadata)
+        args["metadata"] = metadata
+    return dc.field(**args)
     
     # @staticmethod
     # def __call__(rand=False, bind : Callable[[T],Dict[Any,Any]] = None):
@@ -118,10 +189,26 @@ def field(rand=False, bind : Callable[[object],Dict[Any,Any]] = None):
     # # TODO: 
     # return dc.field()
 
+class Input(object): pass
+
+class Output(object): pass
+
 def input(*args, **kwargs):
+    """
+    Marks an input field. Input fields declared on a 
+    top-level component are `bound` to an implicit output. Those
+    on non-top-level components must explicitly be `bound` to an 
+    output. An input field sees the value of the output field 
+    to which it is bound with no delay
+    """
     return dataclasses.field(default_factory=Input)
 
 def output(*args, **kwargs):
+    """
+    Marks an output field. Input fields that are bound to
+    an output field always see its current output value 
+    with no delay.
+    """
     return dc.field(default_factory=Output)
 
 def lock(*args, **kwargs):
@@ -136,26 +223,73 @@ def port():
 def export(*args, bind=None, **kwargs):
     return dc.field(*args, **kwargs)
 
+class ExecKind(enum.Enum):
+    Comb = enum.auto()
+    Sync = enum.auto()
+    Proc = enum.auto()
+
+@dc.dataclass
+class Exec(object):
+    method : Callable = dc.field()
+    kind : ExecKind = dc.field()
+    timebase : Optional[Callable] = field(default=None)
+    t : Optional[Callable] = field(default=None)
+
+def extern(
+    typename,
+    bind,
+    files=None,
+    params=None):
+    """
+    Denotes an instance of an external module
+    """
+    from .struct import Extern
+    return dc.field(default_factory=Extern,
+                    metadata=dict(
+                        typename=typename,
+                        bind=bind,
+                        files=files,
+                        params=params))
+
 def process(T):
-    return T
+    """
+    Marks an always-running process. The specified
+    method must be `async` and take no arguments
+    """
+    return Exec(T, ExecKind.Proc)
 
 def reg(offset=0):
     return dc.field()
     pass
 
-def const(**kwargs):
+def const(default=None):
     return dc.field()
 
-def sync(*args, clock=None, reset=None):
-    # TODO: handle two forms
-    if len(args) == 0:
-        def __call__(T):
-            Annotation.apply(T, AnnotationSync(clock=clock, reset=reset))
-            return T
-        return __call__
-    else:
-        Annotation.apply(args[0], AnnotationSync(clock=clock, reset=reset))
-        return args[0]
+@dc.dataclass
+class ExecSync(Exec):
+    clock : Optional[Callable] = field(default=None)
+    reset : Optional[Callable] = field(default=None)
+
+def sync(clock : Callable, reset : Callable):
+    """
+    Marks a synchronous-evaluation region, which is evaluated on 
+    the active edge of either the clock or reset.
+    Assignments are delayed/nonblocking, which means that only
+    the last assignment to a variable takes effect.
+    """
+    def __call__(T):
+        return ExecSync(method=T, kind=ExecKind.Sync, clock=clock, reset=reset)
+    return __call__
+
+def comb(latch : bool=False):
+    """
+    Marks a combinational evaluation region that is evaluated 
+    whenever one of the variables read by the method changes.
+    """
+    def __call__(T):
+        return Exec(method=T, kind=ExecKind.Comb, )
+    return __call__
+
 
 # def action(*args, **kwargs): 
 #     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):

zuspec/dataclasses/dependency.py

@@ -1,3 +1,18 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
 import abc
 import dataclasses as dc
 from typing import List
@@ -19,4 +34,3 @@ class TrackingDependencyProvider[T](DependencyProvider):
         List of dependencies bound to this provider
         """
         pass
-

zuspec/dataclasses/ports.py

@@ -54,8 +54,3 @@ class Port[T]():
 #         a = self.dat_o().get()
 #         self.dat_o().put(5)
 
-class Input(object):
-    pass
-
-class Output(object):
-    pass

zuspec/dataclasses/std/__init__.py

@@ -0,0 +1,18 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
+
+from .clock_reset import ClockReset
+from .timebase import TimeBase, TimebaseSync

zuspec/dataclasses/std/clock_reset.py

@@ -0,0 +1,35 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
+import abc
+from ..component import Component
+from ..decorators import dataclass, field, output
+from ..bit import Bit
+
+@dataclass
+class ClockReset(Component):
+    period : int = field(default=10)
+    clock : Bit = output()
+    reset : Bit = output()
+
+    @abc.abstractmethod
+    def assert_reset(self): pass
+
+    @abc.abstractmethod
+    def release_reset(self): pass
+
+    @abc.abstractmethod
+    async def next(self, count : int = 1):
+        pass

zuspec/dataclasses/std/timebase.py

@@ -0,0 +1,45 @@
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
+import abc
+from typing import Protocol, TYPE_CHECKING
+from ..decorators import dataclass
+from ..bit import Bit
+from ..component import Component
+
+class TimeBase(Protocol):
+    """
+    TimeBase exposes the notion of design time
+    """
+
+    @abc.abstractmethod
+    async def wait(self, amt : float, units):
+        """Scales the time to the timebase and waits"""
+        ...
+
+
+    @abc.abstractmethod
+    def wait_ev(self, amt : float, units):
+        """Scales the time to the timebase and returns an event"""
+        ...
+
+@dataclass
+class TimebaseSync(TimeBase):
+
+    @abc.abstractmethod
+    async def wait_next(self, count : int = 1):
+        """Waits for 'count' timebase events (eg clocks)"""
+        ...
+

zuspec/dataclasses/struct.py

@@ -3,7 +3,11 @@ from typing import Dict, Optional, Type
 from .decorators import dataclass
 
 @dataclass
-class StructPacked(object):
+class ZuspecTypeBase(object):
+    pass
+
+@dataclass
+class StructPacked(ZuspecTypeBase):
     """
     StructPacked types are fixed-size data structures. 
     Fields may only be of a fixed size. 
@@ -15,7 +19,7 @@ class StructPacked(object):
     pass
 
 @dataclass
-class Struct(object):
+class Struct(ZuspecTypeBase):
     """
     Struct types are data structures that may contain
     variable-size fields. 
@@ -26,6 +30,7 @@ class Struct(object):
     - method
     """
 
+
     # @abc.abstractmethod
     # def bind[T](self, t : T):
     #             t : Type[T], 
@@ -40,3 +45,5 @@ class Struct(object):
     #     pass
 
     pass
+
+class Extern(ZuspecTypeBase): pass

zuspec/dataclasses/tlm.py

@@ -10,3 +10,9 @@ class IPut[T]():
 class IGet[T]():
     get : Callable[[], Awaitable[T]] = dc.field()
 
+@dc.dataclass
+class IReqRsp[ReqT,RspT]():
+    put : Callable[[Type[ReqT]], Awaitable] = dc.field()
+    get : Callable[[], Awaitable[RspT]] = dc.field()
+
+

{zuspec_dataclasses-0.0.1.17421055506rc0.dist-info → zuspec_dataclasses-0.0.1.18247373596rc0.dist-info}/METADATA

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: zuspec-dataclasses
-Version: 0.0.1.17421055506rc0
+Version: 0.0.1.18247373596rc0
 License-File: LICENSE
 Dynamic: license-file

zuspec_dataclasses-0.0.1.18247373596rc0.dist-info/RECORD

@@ -0,0 +1,29 @@
+zuspec/dataclasses/__init__.py,sha256=PLcLoAnWVu-Dqz_mYg8pTZoQ3UuN_EHBnY20m7f8YDk,1353
+zuspec/dataclasses/__version__.py,sha256=w6m6NGjqBy7gs-fG-V3ph2_sw4z-KMRNjIjFqN185gI,829
+zuspec/dataclasses/action.py,sha256=12n8lihUhX0BFPcW370IlPgyEXLUMDSDQ_h_-rZr7ik,1328
+zuspec/dataclasses/addr_reg.py,sha256=yKENXgCf9E5VEbfj0qCcJS-fwnQGdSaXG7t00aqA784,2759
+zuspec/dataclasses/annotation.py,sha256=m_3h065RAR81skrq39wxsJ1V0BxpwiyAWzdTrvW51Gg,1086
+zuspec/dataclasses/bit.py,sha256=qBTt8mj_S4WK6VeRaaqeNzzuvy3P12WigKaeU2Gr0mw,1072
+zuspec/dataclasses/bundle.py,sha256=YIuEQS_4oS3LWQ3Zv3Ib78L6V6QzhDsd2S89BP0dsl8,1626
+zuspec/dataclasses/component.py,sha256=yXSmg87uj_1TaazO99mLv72Z0lAlzzQiBTmn0wI5alo,2056
+zuspec/dataclasses/decorators.py,sha256=gsVQ_84GMjfQgETH1nFK1rW4CbG6ab1yt2eJvxbo8q4,13947
+zuspec/dataclasses/dependency.py,sha256=LukfqqvTUfShrtYdidqZeVMie-l50oAzkpYqo_bqie0,1289
+zuspec/dataclasses/ports.py,sha256=OydeAfPIAef8pCp_3FhL87fq7mrbhiNLa9qfPHkCK1E,1044
+zuspec/dataclasses/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+zuspec/dataclasses/struct.py,sha256=_7Lgf2BbF_WQXSpdKmowR6mATBjqZtqK6VoPPc1tdLg,1077
+zuspec/dataclasses/tlm.py,sha256=sbAlnkYhVidinbiMKBT_mbe5yr1dDU9F_6aKBAXZjjE,431
+zuspec/dataclasses/api/__init__.py,sha256=YwPniS7IHooW5iFCfV2MzKCVf4c4LR7--5SlGOjvGec,830
+zuspec/dataclasses/api/type_processor.py,sha256=4VqIbj-Uo_DqNJpENSq8k5ll5TxhRFlLjq5Psi0Ss7I,956
+zuspec/dataclasses/api/visitor.py,sha256=CduJ6k11xY81_nFl8k0dVSRJt88a21mHem64Yeg6sDI,11852
+zuspec/dataclasses/std/__init__.py,sha256=7xOZCDuEikfg5NRpC0eFGIvgj3hHz7ibtJawzroU4nY,839
+zuspec/dataclasses/std/clock_reset.py,sha256=AveFnqB-OAgWfVr2eA7v9XfAPuE12WtQpSbbE1zhwME,1205
+zuspec/dataclasses/std/timebase.py,sha256=kgkeJ52jHvngdcs8lw5bJ20NDhWmzcAlRmPQ11Qa96A,1468
+zuspec/dataclasses/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zuspec/dataclasses/util/extract_cpp_embedded_dsl.py,sha256=SyMMLumZD6fsubj40hyekYzWyrcoUGTijJH3NmK1ihY,5630
+zuspec/dataclasses/util/gen_cpp_dt_defs/__main__.py,sha256=t3CnHJKcN_N33sxCsDH-R36ghCcQ7xjMcjUrzUT2SGM,3447
+zuspec/impl/__init__.py,sha256=GZWCeBPdVzLR0RNPkmXNXPgdS-2vg5dMC1goTYJs3yI,33
+zuspec_dataclasses-0.0.1.18247373596rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+zuspec_dataclasses-0.0.1.18247373596rc0.dist-info/METADATA,sha256=O74TphkBnh2iHRNubkDsL_at148MqH3qS_f-HGXQwKY,121
+zuspec_dataclasses-0.0.1.18247373596rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zuspec_dataclasses-0.0.1.18247373596rc0.dist-info/top_level.txt,sha256=3WM_V5g1RvpI4_z1TPY_AmroKhWIp6QJo4Vz5Tqbgak,7
+zuspec_dataclasses-0.0.1.18247373596rc0.dist-info/RECORD,,

zuspec/dataclasses/clock.py

@@ -1,3 +0,0 @@
-
-class Clock(object):
-    pass

zuspec/dataclasses/reset.py

@@ -1,3 +0,0 @@
-
-class Reset(object):
-    pass

zuspec/dataclasses/timebase.py

@@ -1,27 +0,0 @@
-import abc
-from .component import Component
-from .decorators import dataclass, input
-from .bit import Bit
-
-@dataclass
-class TimeBase(object):
-    """
-    TimeBase exposes the notion of design time
-    """
-
-    @abc.abstractmethod
-    async def wait(self, amt : float, units):
-        """Scales the time to the timebase and waits"""
-        pass
-
-    @abc.abstractmethod
-    def wait_ev(self, amt : float, units):
-        """Scales the time to the timebase and returns an event"""
-        pass
-
-    pass
-
-class TimeBaseSignal(TimeBase,Component):
-    clock : Bit = input()
-    reset : Bit = input()
-

zuspec_dataclasses-0.0.1.17421055506rc0.dist-info/RECORD

@@ -1,28 +0,0 @@
-zuspec/dataclasses/__init__.py,sha256=N7A7kcH2MWv11kqVA-s0SyKnWBAKD6ijQXJOrzfRyf8,452
-zuspec/dataclasses/__version__.py,sha256=w206wPrAQOLdhYE50Ud54WEWjFUOPqdoT2NoUpjn64o,71
-zuspec/dataclasses/action.py,sha256=z7aMc6e_k_-NCzYDm8K1ymEPfcGeyqlO79of0Gucack,570
-zuspec/dataclasses/addr_reg.py,sha256=QmxPQ8lq1255ZfOjQRGFGWGGwK-pSpPFJ4mdzJlj8dw,1111
-zuspec/dataclasses/annotation.py,sha256=M41iS93Oi8M-ER_ZIBI8CIWJ1bvEMI0nHa-RxbmWJUs,328
-zuspec/dataclasses/bit.py,sha256=Zxm3F04GcfuJczmwCrMuvpcBCunWMZQFffB4JvNterI,614
-zuspec/dataclasses/bundle.py,sha256=6fqjfoTS_-_izl4FlPFgurfOg3tnj_1fmEdSa1FF4C0,781
-zuspec/dataclasses/clock.py,sha256=pM0rO-3bp0SGJccxtU-17vIcF9EaSlqD-q1_9O0of1o,30
-zuspec/dataclasses/component.py,sha256=vzPCmLdAgm-x46Or18RtBYRClVUkbqIZ1yqp1nu5sL4,416
-zuspec/dataclasses/decorators.py,sha256=fSJpsTbahzQdtFtlVhDFSHFFuYmiRxg_3S_W1DpjLDY,9797
-zuspec/dataclasses/dependency.py,sha256=kGxdFqKlviUP7qmvN-FbnXIiqCPdgRRel83feuu8OoU,532
-zuspec/dataclasses/ports.py,sha256=3pbBwdBzDMAJTZ15Qf6sSXB-XOH5cJ-G5H8kQa5JurQ,1106
-zuspec/dataclasses/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-zuspec/dataclasses/reset.py,sha256=DV8tiKq_k-AGUNBbpJCJFx_EEfA07UgUJK2veYli0b0,30
-zuspec/dataclasses/struct.py,sha256=vId0487ZJmhnTbTg421B-iN9PtxNexCv9DMqRO8RXBU,973
-zuspec/dataclasses/timebase.py,sha256=rjEiGB2lNPMTewE-Z4iX-CHnbx1QVTUbtwEXnKMkesI,599
-zuspec/dataclasses/tlm.py,sha256=TjODFwvombQR7AVVI7HlW37MEm22Zu9JdVYpOCU4_Vg,277
-zuspec/dataclasses/api/__init__.py,sha256=HfJhJ_B1RJSpJn5NmWzEK3l2IruubiEKd3xwLDuED6Q,30
-zuspec/dataclasses/api/visitor.py,sha256=8-5er0GxAWnvxhDmiR_OBn2iMxtymtol5qM09ucKdLI,1780
-zuspec/dataclasses/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zuspec/dataclasses/util/extract_cpp_embedded_dsl.py,sha256=SyMMLumZD6fsubj40hyekYzWyrcoUGTijJH3NmK1ihY,5630
-zuspec/dataclasses/util/gen_cpp_dt_defs/__main__.py,sha256=t3CnHJKcN_N33sxCsDH-R36ghCcQ7xjMcjUrzUT2SGM,3447
-zuspec/impl/__init__.py,sha256=GZWCeBPdVzLR0RNPkmXNXPgdS-2vg5dMC1goTYJs3yI,33
-zuspec_dataclasses-0.0.1.17421055506rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-zuspec_dataclasses-0.0.1.17421055506rc0.dist-info/METADATA,sha256=EZDxpqEdg2prfw4jvirp2j5sMETTp0ICrvue99A-Q44,121
-zuspec_dataclasses-0.0.1.17421055506rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-zuspec_dataclasses-0.0.1.17421055506rc0.dist-info/top_level.txt,sha256=3WM_V5g1RvpI4_z1TPY_AmroKhWIp6QJo4Vz5Tqbgak,7
-zuspec_dataclasses-0.0.1.17421055506rc0.dist-info/RECORD,,