moreniius 0.6.3__py3-none-any.whl → 0.8.0__py3-none-any.whl

moreniius/mccode/instance.py

@@ -122,6 +122,9 @@ class NXInstance:
                 if not hasattr(self.nx[name], 'depends_on'):
                     self.nx[name].attrs['depends_on'] = most_dependent
                 most_dependent = outer_transform_dependency(self.nx['transformations'])
+            # Note: the depends_on entry for NX class objects is an optional dataset
+            #       in the HDF5 group. Tools like chexus can verify its presence and
+            #       scippnexus only uses the dataset member of a group for this.
             self.nx['depends_on'] = f'transformations/{most_dependent}'
 
     def get_nx_type(self):
@@ -131,7 +134,7 @@ class NXInstance:
             return COMPONENT_CATEGORY_TO_NEXUS[self.obj.type.category]
         if any(self.obj.type.name.startswith(x) for x in COMPONENT_GROUP_TO_NEXUS):
             return [t for k, t in COMPONENT_GROUP_TO_NEXUS.items() if self.obj.type.name.startswith(k)][0]
-        return 'NXnote'
+        return 'NXcoordinate_system' if self.transforms else 'NXnote'
 
     def default_translation(self):
         import nexusformat.nexus as nexus

moreniius/mccode/instr.py

@@ -53,7 +53,19 @@ class NXInstr:
         return NXfield(str(self.instr))
 
     def expr2nx(self, expr: Union[str, Expr, Any]):
-        from moreniius.utils import link_specifier
+        """Intended to convert *Expr* objects to NeXus-representable objects"""
+        # FIXME this is called to wrap and re-wrap the same data
+        #       during translation of a component with properties. It may be worth
+        #       separating the parameter and component functionality.
+        from moreniius.utils import link_specifier, NotNXdict
+        from nexusformat.nexus import NXlog
+        if hasattr(expr, '_value') and isinstance(getattr(expr, '_value'), NotNXdict):
+            # Avoid unwrapping the non-NX dictionary at this stage since it is
+            # silently converted to a string-like thing which as an __iter__ property
+            return expr
+        if isinstance(expr, NXlog):
+            # Do not decompose a value if we already wrapped it in NXlog
+            return expr
         if not isinstance(expr, str) and hasattr(expr, '__iter__'):
             parts = [self.expr2nx(x) for x in expr]
             return tuple(parts) if isinstance(expr, tuple) else parts
@@ -68,6 +80,10 @@ class NXInstr:
             return evaluated.value
 
         dependencies = [par.name for par in self.instr.parameters if evaluated.depends_on(par.name)]
+        if len(dependencies) == 1 and str(expr) == str(dependencies[0]):
+            from moreniius.utils import linked_nxlog
+            return linked_nxlog(f'{self.nxlog_root}/{dependencies[0]}')
+
         if len(dependencies):
             log.warn(f'The expression {expr} depends on instrument parameter(s) {dependencies}\n'
                      f'A link will be inserted for each; make sure their values are stored at {self.nxlog_root}/')
@@ -77,36 +93,53 @@ class NXInstr:
         return str(expr)
 
     def make_nx(self, nx_class, *args, **kwargs):
+        from nexusformat.nexus import NXlog
+        from moreniius.utils import NotNXdict
         nx_args = [self.expr2nx(expr) for expr in args]
         nx_kwargs = {name: self.expr2nx(expr) for name, expr in kwargs.items()}
-        # logged parameters are sometimes requested as NXfield objects, but should be links to the real NXlog
-        if nx_class == NXfield and len(nx_args) == 1 and isinstance(nx_args[0], NXcollection) and \
-                'expression' in nx_args[0]:
-            not_expr = [x for x in nx_args[0] if x != 'expression']
+
+        # logged parameters are sometimes requested as NXfields, but should be NXlogs
+        want_log = nx_class == NXfield and len(nx_args) == 1
+        nx_arg = nx_args[0] if want_log else None
+        if want_log and isinstance(nx_arg, NXlog):
+            # The NXlog returned by expr2nx doesn't have the needed attributes:
+            for k, v in nx_kwargs.items():
+                nx_arg.attrs[k] = v
+            return nx_arg
+        # Hopefully less often, a collection of links in an NXcollection
+        if want_log and isinstance(nx_arg, NXcollection) and 'expression' in nx_arg:
+            not_expr = [x for x in nx_arg if x != 'expression']
             if len(not_expr) == 1:
-                not_expr_arg = nx_args[0][not_expr[0]]
-                # if isinstance(not_expr_arg, NXfield):
-                #     # We have and want an NXfield, but it might be missing attributes specified in the nx_kwargs
-                #     # Passing the keywords to the NXfield constructor versus this method is not identical,
-                #     # since some keyword arguments are reserved (and only some of which are noted)
-                #     #   Explicit keywords, used in the constructor:
-                #     #       value, name, shape, dtype, group, attrs
-                #     #   Keywords extracted from the kwargs dict, if present (and all controlling HDF5 file attributes?):
-                #     #       chunks, compression, compression_opts, fillvalue, fletcher32, maxshape, scaleoffset, shuffle
-                #     # For now, just assume all keywords provided here are _actually_ attributes for the NXfield
-                #     # which is an extension of a dict, but can *not* use the update method, since the __setitem__
-                #     # method is overridden to wrap inputs in NXattr objects :/
-                #     for k, v in nx_kwargs.items():
-                #         not_expr_arg.attrs[k] = v
-                #     return not_expr_arg
+                arg = nx_arg[not_expr[0]]
+                if isinstance(arg, NXfield):
+                    # if this is a link, we should not add any attributes
+                    # since the filewriter will ignore them
+                    if hasattr(arg, '_value') and isinstance(d:=getattr(arg, '_value'), NotNXdict) and d.get('module', '') == 'link':
+                        return arg
+                    # We have and want an NXfield, but it might be missing attributes specified in the nx_kwargs
+                    # Passing the keywords to the NXfield constructor versus this method is not identical,
+                    # since some keyword arguments are reserved (and only some of which are noted)
+                    #   Explicit keywords, used in the constructor:
+                    #       value, name, shape, dtype, group, attrs
+                    #   Keywords extracted from the kwargs dict, if present (and all controlling HDF5 file attributes?):
+                    #       chunks, compression, compression_opts, fillvalue, fletcher32, maxshape, scaleoffset, shuffle
+                    # For now, just assume all keywords provided here are _actually_ attributes for the NXfield
+                    # which is an extension of a dict, but can *not* use the update method, since the __setitem__
+                    # method is overridden to wrap inputs in NXattr objects :/
+                    for k, v in nx_kwargs.items():
+                        arg.attrs[k] = v
+                    return arg
 
                 # TODO make this return an nx_class once we're sure that nx_kwargs is parseable (no mccode_antlr.Expr)
-                if all(x in not_expr_arg for x in ('module', 'config')):
+                if all(x in arg for x in ('module', 'config')):
                     # This is a file-writer stream directive? So make a group
-                    return NXgroup(entries={not_expr[0]: not_expr_arg}, **nx_kwargs)
+                    grp = NXgroup(entries={not_expr[0]: arg})
+                    for attr, val in nx_kwargs.items():
+                        grp.attrs[attr] = val
+                    return grp
                 print('!!')
-                print(not_expr_arg)
-                return nx_class(not_expr_arg, **nx_kwargs)
+                print(arg)
+                return nx_class(arg, **nx_kwargs)
             else:
                 raise RuntimeError('Not sure what I should do here')
         return nx_class(*nx_args, **nx_kwargs)

moreniius/mccode/mccode.py

@@ -1,3 +1,4 @@
+from nexusformat.nexus import NXfield
 from zenlog import log
 from dataclasses import dataclass, field
 from networkx import DiGraph
@@ -7,7 +8,6 @@ from .instr import NXInstr
 
 log.level('error')
 
-
 @dataclass
 class NXMcCode:
     nx_instr: NXInstr
@@ -19,13 +19,21 @@ class NXMcCode:
 
     def __post_init__(self):
         from copy import deepcopy
+
         for index, instance in enumerate(self.nx_instr.instr.components):
             self.indexes[instance.name] = index
-            self.orientations[instance.name] = deepcopy(instance.orientation)
-        # Attempt to re-center all component dependent orientations on the sample
-        found = (lambda x: self.origin_name == x.name) if self.origin_name else (lambda x: 'samples' == x.type.category)
-        possible_origins = [instance for instance in self.nx_instr.instr.components if found(instance)]
+            # only absolute-positioned or rotated component orientations are needed
+            if instance.at_relative[1] is None or instance.rotate_relative[1] is None:
+                self.orientations[instance.name] = deepcopy(instance.orientation)
 
+        # Attempt to re-center all component dependent orientations on the sample
+        found = (
+            (lambda x: self.origin_name == x.name)
+            if self.origin_name else
+            (lambda x: 'samples' == x.type.category)
+        )
+        possible_origins = [instance for instance in
+                            self.nx_instr.instr.components if found(instance)]
         if not possible_origins:
             msg = '"sample" category components' if self.origin_name is None else f'component named {self.origin_name}'
             log.warn(f'No {msg} in instrument, using ABSOLUTE positions')
@@ -37,18 +45,72 @@ class NXMcCode:
             self.origin_name = possible_origins[0].name
             # find the position _and_ rotation of the origin
             origin = possible_origins[0].orientation
-            # remove this from all components (re-centering on the origin)
-            for name in self.orientations:
-                self.orientations[name] = self.orientations[name] - origin
+            # remove this from all (absolute) components (re-centering on the origin)
+            for name, orientation in self.orientations.items():
+                self.orientations[name] = orientation - origin
 
         if self.graph is None:
             self.graph = self.build_graph()
         if self.reversed_graph is None:
             self.reversed_graph = self.graph.reverse(copy=True)
 
-    def transformations(self, name):
-        from .orientation import NXOrient
-        return NXOrient(self.nx_instr, self.orientations[name]).transformations(name)
+    def transformations(self, name) -> dict[str, NXfield]:
+        from mccode_antlr.instr.orientation import Vector, Angles, Parts
+        from .orientation import NXOrient, NXParts
+
+        def abs_ref(ref):
+            # FIXME find a better way to ensure this is correct
+            return f'/entry/instrument/{ref}'
+
+        def last_ref(refs: list[tuple[str, NXfield]]) -> str | None:
+            try:
+                return next(reversed(refs))[0]
+            except StopIteration:
+                pass
+
+        at_vec, at_rel = self.nx_instr.instr.components[self.indexes[name]].at_relative
+        rot_ang, rot_rel = self.nx_instr.instr.components[self.indexes[name]].rotate_relative
+
+        nx_orientation = None
+        if at_rel is None or rot_rel is None:
+            nx_orientation = NXOrient(self.nx_instr, self.orientations[name])
+
+        if at_rel is None and rot_rel is None:
+            # ABSOLUTE definition, so we pull information from self.orientations
+            # since we had to remove the (possibly different) origin
+            return nx_orientation.transformations(name)
+
+        trans = []
+        if at_rel is not None and rot_rel is not None and at_rel == rot_rel:
+            at_vec = Vector(*at_vec) if isinstance(at_vec, tuple) else at_vec
+            rot_ang = Angles(*rot_ang) if isinstance(rot_ang, tuple) else rot_ang
+            at_parts = Parts.from_at_rotated(at_vec, Angles(), True)
+            rot_parts = Parts.from_at_rotated(Vector(), rot_ang, True)
+            nx_parts = NXParts(self.nx_instr, at_parts, rot_parts)
+            trans.extend(nx_parts.transformations(name, abs_ref(at_rel.name)))
+        else:
+            raise RuntimeError("All mixed reference-type orientations untested. "
+                               "Only 'AT (x, y, z) ABSOLUTE ROTATE (a, b, c) REF' might work")
+        # elif at_rel is None:
+        #     # absolute position with relative rotation
+        #     trans.extend(nx_orientation.position_transformations(name))
+        #     # Get the _rotation_ of the reference to add here before any new rotation
+        #     # FIXME this can only work if rot_rel.name is in self.orientations!
+        #     rel_ori = NXOrient(self.nx_instr, self.orientations[rot_rel.name])
+        #     trans.extend(rel_ori.rotation_transformations(rot_rel.name, last_ref(trans)))
+        #     # Now add our relative rotation onto the referenced rotation
+        #     rot_ang = Angles(*rot_ang) if isinstance(rot_ang, tuple) else rot_ang
+        #     rot = Parts(Parts.from_at_rotated(Vector(), rot_ang, True).stack()).reduce()
+        #     nx_parts = NXParts(self.nx_instr, rot, rot)
+        #     trans.extend(nx_parts.rotation_transformations(name, last_ref(trans)))
+        # elif rot_rel is None:
+        #     # relative position with absolute rotations
+        #     raise RuntimeError("I can not handle this yet")
+        # else:
+        #     # relative position and rotation but different references.
+        #     raise RuntimeError("I cnat no handle this ytet")
+
+        return {k: v for k, v in trans}
 
     def inputs(self, name):
         """Return the other end of edges ending at the named node"""
@@ -64,7 +126,7 @@ class NXMcCode:
         instance = self.nx_instr.instr.components[self.indexes[name]]
         transformations = self.transformations(name)
         nxinst = NXInstance(self.nx_instr, instance, self.indexes[name], transformations, only_nx=only_nx)
-        if transformations and nxinst.nx['transformations'] != transformations:
+        if transformations and nxinst.nx['transformations'] != transformations and name in self.orientations:
             # if the component modifed the transformations group, make sure we don't use our version again
             del self.orientations[name]
         if len(inputs := self.inputs(name)):

moreniius/mccode/orientation.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from zenlog import log
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from mccode_antlr.instr import Orient, Parts, Part
 from nexusformat.nexus import NXfield
 from .instr import NXInstr
@@ -73,27 +73,52 @@ class NXParts:
     position: Parts
     rotation: Parts
 
-    def transformations(self, name: str) -> list[tuple[str, NXfield]]:
-        nxt = []
-        dep = '.'
-        for index, o in enumerate(self.position.stack()):
-            nxt.extend(NXPart(self.instr, o).transformations(f'{name}_t{index}', dep))
-            dep = nxt[-1][0] if len(nxt) and len(nxt[-1]) else '.'
-        for index, o in enumerate(self.rotation.stack()):
-            nxt.extend(NXPart(self.instr, o).transformations(f'{name}_r{index}', dep))
-            dep = nxt[-1][0] if len(nxt) and len(nxt[-1]) else '.'
-        return nxt
+    def _transformations(self, name: str, dep: str, typ: str, stack):
+        nx_transformations = []
+        for i, op in enumerate(stack):
+            parts = NXPart(self.instr, op).transformations(f'{name}_{typ}{i}', dep)
+            nx_transformations.extend(parts)
+            if len(parts) and len(parts[-1]):
+                dep = parts[-1][0]
+        return nx_transformations
+
+    def position_transformations(self, name: str, dep: str | None = None ) -> list[tuple[str, NXfield]]:
+        dep = dep or '.'
+        return self._transformations(name, dep, 't', self.position.stack())
+
+    def rotation_transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        dep = dep or '.'
+        return self._transformations(name, dep, 'r', self.rotation.stack())
+
+    def transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        parts = self.position_transformations(name, dep=dep)
+        # If there were any positioning transformations, we need to update
+        # the dependency chained name, otherwise it should stay the same
+        dep = parts[-1][0] if len(parts) and len(parts[-1]) else dep
+        return parts + self.rotation_transformations(name, dep=dep)
 
 
 @dataclass
 class NXOrient:
     instr: NXInstr
     do: Orient
+    nx_parts: NXParts | None = None
 
-    def transformations(self, name: str) -> dict[str, NXfield]:
+    def __post_init__(self):
         # collapse all possible chained orientation information
         # But keep the rotations and translations separate
         pos, rot = self.do.position_parts(), self.do.rotation_parts()
         # make an ordered list of the requisite NXfield entries
-        nxt = NXParts(self.instr, pos, rot).transformations(name)
-        return {k: v for k, v in nxt}
+        self.nx_parts = NXParts(self.instr, pos, rot)
+
+    def transformations(self, name: str) -> dict[str, NXfield]:
+        # make an ordered list of the requisite NXfield entries, and turn it into a dict
+        return {k: v for k, v in self.nx_parts.transformations(name)}
+
+    def position_transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        return self.nx_parts.position_transformations(name, dep)
+
+    def rotation_transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        return self.nx_parts.rotation_transformations(name, dep)
+
+

moreniius/utils.py

@@ -1,5 +1,5 @@
 from mccode_antlr.instr import Instance
-from nexusformat.nexus import NXevent_data, NXfield
+from nexusformat.nexus import NXevent_data, NXfield, NXlog
 
 class NotNXdict:
     """Wrapper class to prevent NXfield-parsing of the held dictionary"""
@@ -16,6 +16,10 @@ class NotNXdict:
         from json import dumps
         return dumps(self.value)
 
+    def get(self, item, default=None):
+        return self.value.get(item, default)
+
+
 
 def outer_transform_dependency(transformations):
     """For a NXtransformations group, find the most-dependent transformation name
@@ -175,6 +179,26 @@ def ev44_event_data_group(source: str, topic: str) -> NXevent_data:
     return NXevent_data(data=ess_flatbuffer_specifier('ev44', {'source': source, 'topic': topic}))
 
 
+def nxlog_data_links(source: str):
+    """
+    Return link module specifications for the datasets inserted by a f144 module
+    """
+    datasets = (
+        'alarm_message', 'alarm_severity', 'alarm_time', 'average_value',
+        'connection_status', 'connection_status_time', 'cue_index',
+        'cue_timestamp_zero', 'description', 'maximum_value', 'minimum_value',
+        'time', 'value'
+    )
+    return {k: link_specifier(k, f'{source}/{k}') for k in datasets}
+
+
+def linked_nxlog(source: str, attrs: dict | None = None) -> NXlog:
+    nxlog = NXlog(**nxlog_data_links(source))
+    if attrs:
+        nxlog.attrs.update(attrs)
+    return nxlog
+
+
 def link_specifier(name: str, source: str) -> NotNXdict:
     """
     Constructs a specifier to insert a NeXus link into an ESS produced NeXus file

{moreniius-0.6.3.dist-info → moreniius-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moreniius
-Version: 0.6.3
+Version: 0.8.0
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Development Status :: 2 - Pre-Alpha
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.14
 Description-Content-Type: text/markdown
 Requires-Dist: zenlog>=1.1
 Requires-Dist: platformdirs>=3.11
-Requires-Dist: mccode-antlr[hdf5]>=0.17.0
-Requires-Dist: nexusformat>=1.0.6
+Requires-Dist: mccode-antlr[hdf5]>=0.17.2
+Requires-Dist: nexusformat>=2.0.0
 Requires-Dist: networkx
 
 # moreniius

moreniius-0.8.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+moreniius/__init__.py,sha256=33SUBkXWhH5rog5oaGJr1Kwqjhwz97w4E0Da7rArYi4,154
+moreniius/additions.py,sha256=6Hhhc4LDUsnBj27Iil-EFFzQm1xd2M45hfcVQYEjxiI,17615
+moreniius/moreniius.py,sha256=UZgQycAed5OWIqxYXZLaD68YUHFgQ8fVb-aCP6hvT9Q,1544
+moreniius/nexus_structure.py,sha256=C_ohhilsE6xdfSpFVhsFEK9EC3sBXPGWxCIGk_4UFvI,1853
+moreniius/nxoff.py,sha256=WHp9wYNn_4Hcx8Nzi9rpX1p8_iwI-AdgTQouSAEG8N4,3288
+moreniius/utils.py,sha256=WhKQ5NzzwiIruNtaSC2FbmNxNa570GqL4hwGIR4WLwA,9982
+moreniius/writer.py,sha256=zgrbo7RfAriAGrOpPhFHSwwn3yWG4_ZJndIi6HhTzss,6815
+moreniius/mccode/__init__.py,sha256=1QiZdh90G3gp_WlVpdJB_ZGauoW0GJEQ13Nelaqa5JE,151
+moreniius/mccode/comp.py,sha256=iaOooI2nIevA0Vhz5jZQJCqXYgmZ3jMm0s3gUtR8Unc,9637
+moreniius/mccode/instance.py,sha256=J0NgNLlJwe9YshZZhKxpH6IixLe9kMjhRyhRfI7uJQM,8355
+moreniius/mccode/instr.py,sha256=jpIKir3xiZGSq0uP3wMevOZ-6dUvfvsgXG0oaVK4pEk,7864
+moreniius/mccode/mccode.py,sha256=6CsAF4nKVEyfPv7mrthTAUYirUiGzb0zk2DcsfSFLh8,7489
+moreniius/mccode/orientation.py,sha256=Y5u_c2Wt3lAAAwohKO223v68WNUjWWy58ZjyEuMzQOk,5122
+moreniius-0.8.0.dist-info/METADATA,sha256=cYaaykjkYD7K09_mcf6S-KGrK5KHSRHth3XRmhkANc8,946
+moreniius-0.8.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+moreniius-0.8.0.dist-info/entry_points.txt,sha256=Ga3k4P4fyBt5_dJ03Oapic2Qlgqv9jufQGdxWiz_j2A,63
+moreniius-0.8.0.dist-info/top_level.txt,sha256=RzMo23UfVhgQeuOYeS5P9I0qVbxx4Gbe6Roc29Mr02c,10
+moreniius-0.8.0.dist-info/RECORD,,

{moreniius-0.6.3.dist-info → moreniius-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

moreniius-0.6.3.dist-info/RECORD

@@ -1,18 +0,0 @@
-moreniius/__init__.py,sha256=33SUBkXWhH5rog5oaGJr1Kwqjhwz97w4E0Da7rArYi4,154
-moreniius/additions.py,sha256=6Hhhc4LDUsnBj27Iil-EFFzQm1xd2M45hfcVQYEjxiI,17615
-moreniius/moreniius.py,sha256=UZgQycAed5OWIqxYXZLaD68YUHFgQ8fVb-aCP6hvT9Q,1544
-moreniius/nexus_structure.py,sha256=C_ohhilsE6xdfSpFVhsFEK9EC3sBXPGWxCIGk_4UFvI,1853
-moreniius/nxoff.py,sha256=WHp9wYNn_4Hcx8Nzi9rpX1p8_iwI-AdgTQouSAEG8N4,3288
-moreniius/utils.py,sha256=R81eHjc0EWjMsP-Z8WI9sZkc_QY357z_aYziflQAUEU,9238
-moreniius/writer.py,sha256=zgrbo7RfAriAGrOpPhFHSwwn3yWG4_ZJndIi6HhTzss,6815
-moreniius/mccode/__init__.py,sha256=1QiZdh90G3gp_WlVpdJB_ZGauoW0GJEQ13Nelaqa5JE,151
-moreniius/mccode/comp.py,sha256=iaOooI2nIevA0Vhz5jZQJCqXYgmZ3jMm0s3gUtR8Unc,9637
-moreniius/mccode/instance.py,sha256=yydYeMGITlZrVWBVYregBWQ0Sd_2A71hgoyCrLLW-Jk,8058
-moreniius/mccode/instr.py,sha256=D4B3ylD4BMfkiP5t2hx5xop9c7yk7QVSleT1wvpK17E,6161
-moreniius/mccode/mccode.py,sha256=0Ck9xFUHU3EkBGTNIXelMgtLA1JXOs976Sj2wXfMQng,4237
-moreniius/mccode/orientation.py,sha256=khT0jTMXyXkPCoEpDg-eLKulF-J2wIqNhUi1NzFWvto,3907
-moreniius-0.6.3.dist-info/METADATA,sha256=1S-tgxjhVxaMc4a9BCqGIiMqI5WRCAGdSQMGVJTiOH4,946
-moreniius-0.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-moreniius-0.6.3.dist-info/entry_points.txt,sha256=Ga3k4P4fyBt5_dJ03Oapic2Qlgqv9jufQGdxWiz_j2A,63
-moreniius-0.6.3.dist-info/top_level.txt,sha256=RzMo23UfVhgQeuOYeS5P9I0qVbxx4Gbe6Roc29Mr02c,10
-moreniius-0.6.3.dist-info/RECORD,,