amityping 1.3.0__py3-none-any.whl

amitypes/__init__.py

@@ -0,0 +1,79 @@
+import sys
+import json
+import numpy
+import typing
+import inspect
+import importlib
+
+from amitypes.array import NumPyTypeDict
+from amitypes.array import *    # noqa ignore=F405
+from amitypes.hsd import *      # noqa ignore=F405
+from amitypes.waveform import * # noqa ignore=F405
+from amitypes.source import *   # noqa ignore=F405
+from amitypes.scan import *     # noqa ignore=F405
+
+
+__version__ = '1.3.0'
+
+
+def dumps(cls):
+    if inspect.isclass(cls):
+        if isinstance(cls, typing.GenericAlias):
+            return str(cls)
+        elif cls.__module__ in ['builtins']:
+            return cls.__name__
+        else:
+            return "%s.%s" % (cls.__module__, cls.__name__)
+    elif isinstance(cls, typing.TypeVar):
+        return "%s.%s" % (cls.__module__, cls.__name__)
+    else:
+        return str(cls)
+
+
+def loads(type_str):
+    parts = type_str.split('.')
+    if len(parts) > 1 and parts[0] != __name__:
+        try:
+            mod = importlib.import_module(parts[0])
+            setattr(sys.modules[__name__], mod.__name__, mod)
+        except ModuleNotFoundError:
+            pass
+
+    cls = eval(type_str.replace('amitypes.', ''))
+
+    return cls
+
+
+class TypeDumper(object):
+
+    def __init__(self, ttype):
+        self.ttype = ttype
+
+    def __repr__(self):
+        return dumps(self.ttype)
+
+
+class TypeEncoder(json.JSONEncoder):
+
+    def default(self, obj):
+        nptopy = NumPyTypeDict.get(type(obj))
+        if nptopy is not None:
+            return nptopy(obj)
+        elif isinstance(obj, numpy.ndarray):
+            return obj.tolist()
+        elif inspect.isclass(obj):
+            if isinstance(obj, typing.GenericAlias):
+                return str(obj)
+            elif obj.__module__ in ['builtins']:
+                return obj.__name__
+            else:
+                return "%s.%s" % (obj.__module__, obj.__name__)
+        elif isinstance(obj, typing.TypeVar):
+            return "%s.%s" % (obj.__module__, obj.__name__)
+        elif isinstance(obj, (typing._GenericAlias, typing._SpecialForm, typing.GenericAlias)):
+            return str(obj)
+        else:
+            return json.JSONEncoder.default(self, obj)
+
+
+T = typing.TypeVar('T')

amitypes/array.py

@@ -0,0 +1,93 @@
+import numpy
+import typing
+import inspect
+
+
+__all__ = [
+    'NumPyTypeDict',
+    'Array',
+    'ArrayMeta',
+    'Array1d',
+    'Array2d',
+    'Array3d',
+]
+
+
+def _map_numpy_types():
+    nptypemap = {}
+    for name, dtype in inspect.getmembers(numpy, lambda x: inspect.isclass(x) and issubclass(x, numpy.generic)):
+        try:
+            ptype = None
+            if 'time' in name:
+                ptype = type(dtype(0, 'D').item())
+            elif 'object' not in name:
+                ptype = type(dtype(0).item())
+
+            # if it is still a numpy dtype don't make a mapping
+            if not issubclass(ptype, numpy.generic):
+                nptypemap[dtype] = ptype
+        except TypeError:
+            pass
+
+    return nptypemap
+
+
+NumPyTypeDict = _map_numpy_types()
+
+
+class ArrayMeta(type):
+    pass
+
+
+class Array1dMeta(ArrayMeta):
+
+    @classmethod
+    def __instancecheck__(cls, inst) -> bool:
+        if not isinstance(inst, numpy.ndarray):
+            return False
+
+        if inst.ndim != 1:
+            return False
+
+        return True
+
+
+class Array2dMeta(ArrayMeta):
+
+    @classmethod
+    def __instancecheck__(cls, inst) -> bool:
+        if not isinstance(inst, numpy.ndarray):
+            return False
+
+        if inst.ndim != 2:
+            return False
+
+        return True
+
+
+class Array3dMeta(ArrayMeta):
+
+    @classmethod
+    def __instancecheck__(cls, inst) -> bool:
+        if not isinstance(inst, numpy.ndarray):
+            return False
+
+        if inst.ndim != 3:
+            return False
+
+        return True
+
+
+class Array1d(metaclass=Array1dMeta):
+    pass
+
+
+class Array2d(metaclass=Array2dMeta):
+    pass
+
+
+class Array3d(metaclass=Array3dMeta):
+    pass
+
+
+Array = typing.Union[Array3d, Array2d, Array1d, list[float], tuple[float]]

amitypes/hsd.py

@@ -0,0 +1,108 @@
+import typing
+from mypy_extensions import TypedDict
+from amitypes.array import Array1d
+
+
+__all__ = [
+    'TypedDict',
+    'PeakTimes',
+    'HSDSegementPeakTimes',
+    'HSDPeakTimes',
+    'Peaks',
+    'HSDSegmentPeaks',
+    'HSDPeaks',
+    'HSDSegmentWaveforms',
+    'HSDWaveforms',
+    'HSDAssemblies',
+    'HSDTypes',
+]
+
+
+PeakTimes = list[Array1d]
+
+
+HSDSegementPeakTimes = TypedDict(
+    "HSDSegementPeakTimes",
+    {
+        '0': PeakTimes,
+        '1': PeakTimes,
+        '2': PeakTimes,
+        '3': PeakTimes,
+        '4': PeakTimes,
+        '5': PeakTimes,
+        '6': PeakTimes,
+        '7': PeakTimes,
+        '8': PeakTimes,
+        '9': PeakTimes,
+        '10': PeakTimes,
+        '11': PeakTimes,
+        '12': PeakTimes,
+        '13': PeakTimes,
+        '14': PeakTimes,
+        '15': PeakTimes,
+    },
+    total=False)
+
+
+HSDPeakTimes = dict[int, HSDSegementPeakTimes]
+
+Peaks = tuple[list[int], list[Array1d]]
+
+
+HSDSegmentPeaks = TypedDict(
+                    "HSDSegmentPeaks",
+                    {
+                       '0': Peaks,
+                       '1': Peaks,
+                       '2': Peaks,
+                       '3': Peaks,
+                       '4': Peaks,
+                       '5': Peaks,
+                       '6': Peaks,
+                       '7': Peaks,
+                       '8': Peaks,
+                       '9': Peaks,
+                       '10': Peaks,
+                       '11': Peaks,
+                       '12': Peaks,
+                       '13': Peaks,
+                       '14': Peaks,
+                       '15': Peaks,
+                    },
+                    total=False)
+
+
+HSDPeaks = dict[int, HSDSegmentPeaks]
+
+
+HSDSegmentWaveforms = TypedDict(
+                        "HSDSegmentWaveforms",
+                        {
+                          'times': Array1d,
+                          '0': Array1d,
+                          '1': Array1d,
+                          '2': Array1d,
+                          '3': Array1d,
+                          '4': Array1d,
+                          '5': Array1d,
+                          '6': Array1d,
+                          '7': Array1d,
+                          '8': Array1d,
+                          '9': Array1d,
+                          '10': Array1d,
+                          '11': Array1d,
+                          '12': Array1d,
+                          '13': Array1d,
+                          '14': Array1d,
+                          '15': Array1d,
+                        },
+                        total=False)
+
+
+HSDWaveforms = dict[int, HSDSegmentWaveforms]
+
+
+HSDAssemblies = typing.TypeVar('HSDAssemblies')
+
+
+HSDTypes = {HSDPeakTimes, HSDPeaks, HSDWaveforms, HSDAssemblies}

amitypes/scan.py

@@ -0,0 +1,46 @@
+from amitypes.array import Array1d
+
+
+__all__ = [
+    'ScanControls',
+    'ScanMonitors',
+    'ScanLabels',
+    'ScanTypes',
+    'ScanControlType',
+    'ScanMonitorType',
+    'ScanLabelType',
+]
+
+
+class ScanMeta(type):
+
+    @classmethod
+    def __instancecheck__(cls, inst) -> bool:
+        if not isinstance(inst, list) and not isinstance(inst, Array1d):
+            return False
+
+        return True
+
+
+class ScanControls(metaclass=ScanMeta):
+    pass
+
+
+class ScanMonitors(metaclass=ScanMeta):
+    pass
+
+
+class ScanLabels(metaclass=ScanMeta):
+    pass
+
+
+ScanTypes = {ScanControls, ScanMonitors, ScanLabels}
+
+
+ScanControlType = float
+
+
+ScanMonitorType = tuple[float, float]
+
+
+ScanLabelType = str

amitypes/source.py

@@ -0,0 +1,85 @@
+import typing
+import dataclasses
+import collections.abc
+
+
+__all__ = [
+    'Detector',
+    'Group',
+    'DataSource',
+    'PyArrowTypes',
+]
+
+
+T = typing.TypeVar('T', bound='Serializable')
+
+
+class Serializable:
+    @property
+    def fields(self) -> typing.Iterable[dataclasses.Field]:
+        return dataclasses.fields(self)
+
+    def _dropped(self) -> typing.Generator[dataclasses.Field, None, None]:
+        for field in self.fields:
+            if field.metadata.get('drop', False):
+                yield field
+
+    def _undropped(self) -> typing.Generator[dataclasses.Field, None, None]:
+        for field in self.fields:
+            if not field.metadata.get('drop', False):
+                yield field
+
+    def _serialize(self) -> dict:
+        state = self.__dict__.copy()
+        for field in self._dropped():
+            del state[field.name]
+        return state
+
+    @classmethod
+    def _deserialize(cls: typing.Type[T], data: dict) -> T:
+        return cls(**data)
+
+    def __getstate__(self) -> dict:
+        return self._serialize()
+
+    def __setstate__(self, state: dict) -> None:
+        for field in self._dropped():
+            state[field.name] = field.default
+        self.__dict__.update(state)
+
+
+@dataclasses.dataclass
+class Detector(Serializable):
+    name: str
+    src: str
+    type: str
+    det: typing.Any = dataclasses.field(default=None, metadata={'drop': True})
+
+
+@dataclasses.dataclass
+class Group(Serializable, collections.abc.Mapping):
+    name: str
+    src: str
+    type: str
+    data: dict = dataclasses.field(default_factory=dict)
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __len__(self):
+        return len(self.data)
+
+
+@dataclasses.dataclass
+class DataSource(Serializable):
+    cfg: dict
+    key: int = 0
+    run: typing.Any = dataclasses.field(default=None, metadata={'drop': True})
+    step: typing.Any = dataclasses.field(default=None, metadata={'drop': True})
+    evt: typing.Any = dataclasses.field(default=None, metadata={'drop': True})
+
+
+PyArrowTypes = {Detector, Group, DataSource}

amitypes/waveform.py

@@ -0,0 +1,66 @@
+import typing
+from amitypes.array import Array1d, Array2d
+
+
+__all__ = [
+    'MultiChannelInt',
+    'MultiChannelFloat',
+    'MultiChannelScalar',
+    'MultiChannelScalarTypes',
+    'AcqirisTimes',
+    'AcqirisWaveforms',
+    'AcqirisChannel',
+    'AcqirisTypes',
+    'GenericWfTimes',
+    'GenericWfWaveforms',
+    'GenericWfChannel',
+    'GenericWfTypes',
+    'MultiChannelWaveform',
+    'MultiChannelWaveformTypes',
+]
+
+
+class MultiChannelInt(Array1d):
+    pass
+
+
+class MultiChannelFloat(Array1d):
+    pass
+
+
+MultiChannelScalar = typing.Union[MultiChannelInt, MultiChannelFloat, Array1d]
+
+
+MultiChannelScalarTypes = {MultiChannelInt, MultiChannelFloat}
+
+
+class AcqirisTimes(Array2d):
+    pass
+
+
+class AcqirisWaveforms(Array2d):
+    pass
+
+
+AcqirisChannel = Array1d
+
+
+AcqirisTypes = {AcqirisTimes, AcqirisWaveforms}
+
+
+GenericWfTimes = list[Array1d]
+
+
+GenericWfWaveforms = list[Array1d]
+
+
+GenericWfChannel = Array1d
+
+
+GenericWfTypes = {GenericWfTimes, GenericWfWaveforms}
+
+
+MultiChannelWaveform = typing.Union[AcqirisTimes, AcqirisWaveforms, GenericWfTimes, GenericWfWaveforms, Array2d]
+
+
+MultiChannelWaveformTypes = AcqirisTypes | GenericWfTypes

amityping-1.3.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: amityping
+Version: 1.3.0
+Summary: LCLS analysis monitoring type annotations
+Author: Seshu Yamajala, Daniel Damiani
+License: 
+        Copyright (c) 2019, The Board of Trustees of the Leland Stanford Junior 
+        University, through SLAC National Accelerator Laboratory (subject to receipt 
+        of any required approvals from the U.S. Dept. of Energy). All rights reserved. 
+        Redistribution and use in source and binary forms, with or without 
+        modification, are permitted provided that the following conditions are met:
+         
+        (1) Redistributions of source code must retain the above copyright notice, 
+            this list of conditions and the following disclaimer. 
+        
+        (2) Redistributions in binary form must reproduce the above copyright notice, 
+            this list of conditions and the following disclaimer in the documentation 
+            and/or other materials provided with the distribution. 
+        
+        (3) Neither the name of the Leland Stanford Junior University, SLAC National 
+            Accelerator Laboratory, U.S. Dept. of Energy nor the names of its 
+            contributors may be used to endorse or promote products derived from this 
+            software without specific prior written permission. 
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+        ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+        WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER, THE UNITED STATES GOVERNMENT, 
+        OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+        EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
+        OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+        INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+        CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
+        IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+        OF SUCH DAMAGE.
+        
+        You are under no obligation whatsoever to provide any bug fixes, patches, or 
+        upgrades to the features, functionality or performance of the source code 
+        ("Enhancements") to anyone; however, if you choose to make your Enhancements 
+        available either publicly, or directly to SLAC National Accelerator Laboratory, 
+        without imposing a separate written license agreement for such Enhancements, 
+        then you hereby grant the following license: a non-exclusive, royalty-free 
+        perpetual license to install, use, modify, prepare derivative works, incorporate
+        into other computer software, distribute, and sublicense such Enhancements or 
+        derivative works thereof, in binary and source code form.
+        
+Project-URL: Homepage, https://github.com/slac-lcls/amityping
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Requires-Dist: mypy_extensions
+Dynamic: license-file
+
+# amityping
+Provides typing hints to be shared between LCLS-II analysis packages.

amityping-1.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+amitypes/__init__.py,sha256=9jFzhIxYOoQDFxRM0QSmlZ3rENQ6KRappP-ZLjht6nI,2170
+amitypes/array.py,sha256=m3VeNgQs3z6M1bXDF9FwBQTGy9Y7RV725PW7SjDFjQg,1765
+amitypes/hsd.py,sha256=xxlI45DvwWXjafc8i3pjliEDuLdvc1UKtshQaApkROQ,2704
+amitypes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amitypes/scan.py,sha256=DWkxvRpweRKl_N1fzO9N0bPBQNgBe5kwxhjBHnvlcPo,694
+amitypes/source.py,sha256=bs_NNiWGnYaWD4Kls9RbtGkfIT34fcuhnHlBee8mv8g,2111
+amitypes/waveform.py,sha256=aodDK-wuNfOdBFefrCcmp50t2P1CKWL7Hf8iryO7WjA,1145
+amityping-1.3.0.dist-info/licenses/LICENSE.md,sha256=8hRJDTIZbSOBPwZ2Qus_Nx-OT1bZDHWirO4-RvMaFGQ,2500
+amityping-1.3.0.dist-info/METADATA,sha256=Vl20HCFNvyCwmGS5nRU1RNkUa0YyCmwrw_0JVCDLxfY,3697
+amityping-1.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+amityping-1.3.0.dist-info/top_level.txt,sha256=SGGFo32pTkEfBNEzaSS60FZmpAPHiuulYfRoWetZKMM,9
+amityping-1.3.0.dist-info/RECORD,,

amityping-1.3.0.dist-info/WHEEL

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

amityping-1.3.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,40 @@
+
+Copyright (c) 2019, The Board of Trustees of the Leland Stanford Junior 
+University, through SLAC National Accelerator Laboratory (subject to receipt 
+of any required approvals from the U.S. Dept. of Energy). All rights reserved. 
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+ 
+(1) Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer. 
+
+(2) Redistributions in binary form must reproduce the above copyright notice, 
+    this list of conditions and the following disclaimer in the documentation 
+    and/or other materials provided with the distribution. 
+
+(3) Neither the name of the Leland Stanford Junior University, SLAC National 
+    Accelerator Laboratory, U.S. Dept. of Energy nor the names of its 
+    contributors may be used to endorse or promote products derived from this 
+    software without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER, THE UNITED STATES GOVERNMENT, 
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+OF SUCH DAMAGE.
+
+You are under no obligation whatsoever to provide any bug fixes, patches, or 
+upgrades to the features, functionality or performance of the source code 
+("Enhancements") to anyone; however, if you choose to make your Enhancements 
+available either publicly, or directly to SLAC National Accelerator Laboratory, 
+without imposing a separate written license agreement for such Enhancements, 
+then you hereby grant the following license: a non-exclusive, royalty-free 
+perpetual license to install, use, modify, prepare derivative works, incorporate
+into other computer software, distribute, and sublicense such Enhancements or 
+derivative works thereof, in binary and source code form.

amityping-1.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+amitypes