ialdev-core 0.1.0__py3-none-any.whl

iad/core/wrap.py

@@ -0,0 +1,420 @@
+from __future__ import annotations
+
+import collections
+import enum
+import re
+import sys as _sys
+from functools import wraps
+from typing import Collection, Optional, Type, Callable, Sequence, Literal, Generic, TypeVar
+
+
+def name_func_outputs(func, names: Collection[str] = None, *,
+                      out_type: str | Type[tuple | dict] = None,
+                      adjust=False, nest=None):
+    """Turns a function returning a tuple of items into one returning
+    a named tuple or a dict with items assigned with provided names.
+
+    - Converts into a tuple, if typename str or None (same as str=='<func_name>_out').
+    - Converts into dict if typename is ``dict``
+
+    If number of items in the output does not match that of names,
+    depending on the value of ``adjust`` argument:
+
+    - ``False`` - raise ``TypeError``
+    - ``True`` - uses first ``len(names)`` and raise only if ``len(output)`` is bigger
+    - ``None`` - returns output without change
+
+    Special checking is done for the case of nested wrapping attempts,
+    which are being tracked and depending on the argument ``nest``:
+    - ``False`` - raise ``RuntimeError``
+    - ``True``  - allow nested wrapping and return multi-wrapped function
+    - ``None``  - ignore nested wrapping request and return the input function
+
+    Example::
+
+    >>> f0 = lambda x: tuple(range(x)) if x > 1 else 0
+    >>> name_func_outputs(f0, list('xyz'))(3)
+    <lambda_out> x: 0, y: 1, z: 2
+
+    >>> name_func_outputs(f0, list('xyz'), out_type=dict, adjust=True)(2)
+    {'x': 0, 'y': 1}
+
+    :param func: the function to wrap
+    :param names: collection of names to match the function's outputs or named tuple
+    :param out_type: name of namedtuple or namedtuple class
+    :param adjust: adjust names length to the output length
+    :param nest: allow nested `name_outputs` wrappings
+    :return: new function with dict output
+    """
+
+    def out_len_error(n):
+        raise RuntimeError(f"Cant wrap a {n} outputs of {func_name} in {ln} names")
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        out = func(*args, **kwargs)
+        if not isinstance(out, tuple):
+            if len(names) == 0 or adjust is None: return out
+            if len(names) == 1 or adjust is True: out = (out,)
+            if adjust is False: out_len_error(1)
+        else:
+            if (lo := len(out)) > ln: out_len_error(lo)
+            if lo == ln or adjust is True: return construct(out)
+            if adjust is None: return out  # from here its always lo < ln
+            out_len_error(lo)
+        return construct(out)
+
+    func_name = re.sub(r'\W', '', func.__name__)
+    if names is not None:
+        is_str = lambda x: isinstance(x, str)
+        if isinstance(names, str) or not all(map(is_str, names)):
+            raise TypeError("names must be a collection of strings")
+        if out_type is None:
+            out_type = f"{func_name}_out"
+
+        if isinstance(out_type, str):
+            construct = lambda out: namedtuple(
+                out_type, names[:(len(out) if adjust else None)]
+            )(*out)
+        elif issubclass(out_type, dict):
+            construct = lambda out: dict(zip(names, out))
+        else:
+            raise TypeError("Given names typename must be a dict class or str or None")
+    elif isinstance(out_type, tuple) and hasattr(out_type, '_fields'):
+        names = out_type._fields
+        construct = lambda out: out_type(*out)
+    else:
+        raise TypeError("typename must be namedtuple class if names are not provided")
+    ln = len(names)
+
+    # check if attempting re-wrap the function in the same way
+    attr = dict(names=names, out_type=out_type, prev=None, nest=0)
+    if prev_attr := getattr(func, '_name_outputs', None):
+        if prev_attr['out_type'] == out_type and prev_attr['names'] == names:
+            if nest is None:  # function is already wrapped as requested
+                return func
+            elif nest is False:
+                raise RuntimeError(f'Re-wrapping name_outputs with {attr}')
+        attr['prev'] = prev_attr
+        attr['nest'] = prev_attr['nest'] + 1
+    setattr(wrapper, '_name_outputs', attr)
+    return wrapper
+
+
+def doc_from(src: type | Callable, merge: Literal['append', 'prepend', 'anchor', 'replace'] = 'append', cite=False):
+
+    def merger(obj):
+        doc = (f'Doc from {src.__qualname__}:\n' if cite else '') + (src.__doc__ or '')
+        if not obj.__doc__ or merge == 'replace':
+            obj.__doc__ = doc
+        if merge == 'append':
+            obj.__doc__ += doc
+        elif merge == 'prepend':
+            obj.__doc__ = doc + '\n' + obj.__doc__
+        elif merge == 'anchor':
+            obj.__doc__ = obj.__doc__.replace('<<anchor>>', f'{doc}')
+        else:
+            raise NameError(f'Unknown doc merging method {merge}')
+        return obj
+
+    return merger
+
+
+@doc_from(name_func_outputs)
+def name_outputs(names: Optional[Collection[str]] = None, *,
+                 out_type: str | Type[tuple | dict] | None = None,
+                 adjust=False, nest=None):
+    f"""{name_func_outputs.__doc__}"""
+
+    def convert(func):
+        return name_func_outputs(func, names, out_type=out_type, adjust=adjust, nest=nest)
+    return convert
+
+
+name_outputs.__doc__ = name_func_outputs.__doc__
+
+
+class NamedTupleI:
+    """
+    Implements Interface of ``NamedTuple`` classes.
+
+    Don't subclass it directly, use instead:
+     - either ``namedtuple`` function in this module
+     - or ``NamedTupleMeta`` metaclass
+
+    It can be used for type checking though:
+    ::
+            isinstance(obj, NamedTupleI)
+
+    instead of
+    ::
+            isinstance(type(obj), NamedTupleMeta)
+    """
+    from .nptools import array_info_str
+
+    _fields: list[str]
+    __iter__: Callable
+
+    def __init__(self, *args, **kws): ...
+
+    def __repr__(self):
+        val_str = lambda v: (NamedTupleI.array_info_str(v, stats=False)
+                             if hasattr(v, 'shape') and hasattr(v, 'ndim') else str(v))
+        fields_str = (f'{k}: {val_str(v)}' for k, v in zip(self._fields, self))
+
+        end, sep = '<end>', '<sep>'
+        s = f"<{self.__class__.__name__}> {end}" + sep.join(fields_str)
+        end_str, sep_str = ['\n\t'] * 2 if len(s) > 50 else ['', ', ']
+        return s.replace(end, end_str).replace(sep, sep_str)
+
+    def _part(self, *items: str | int, name: Optional[str] = None):
+        """Return a part of tuple items as a new namedtuple
+
+        :param name: name of the new namedtuple class
+        :param items: fields names to extract (in this order!)
+        """
+        name = name or 'Part'
+
+        def extractor(elements):
+            for elm in elements:
+                if isinstance(elm, int):
+                    yield self._fields[elm], tuple.__getitem__(self, elm)
+                elif isinstance(elm, str):
+                    yield elm, getattr(self, elm)
+                elif isinstance(elm, slice):
+                    for item in zip(self._fields[elm], tuple.__getitem__(self, elm)):
+                        yield item
+                else:
+                    raise TypeError("Invalid reference to tuple element")
+
+        _fields, _items = zip(*extractor(items))
+        return namedtuple(name, _fields)(*_items)
+
+    def apply(self, func):
+        return self.__class__(*(map(func, self)))
+
+    def __add__(self, other):
+        return namedtuple('Combined', [*self._fields, *other._fields])(*self, *other)
+
+    @staticmethod
+    def __build_reduced__(typename, fields, values, module):
+        return namedtuple(typename, fields, module=module)(*values)
+
+    def __reduce__(self):
+        """Override pickle machinery to support dynamically defined or nested named tuples"""
+        cls = self.__class__
+        return (
+            NamedTupleI.__build_reduced__,
+            (cls.__name__, self._fields, [*self], cls.__module__),  # passed to __build_reduced__
+            {})  # no other state information is used
+
+
+class NamedTupleMeta(type):
+    @staticmethod
+    def _find_module(level=1, module=None):
+        if module is None:
+            try:
+                module = _sys._getframe(level).f_globals.get('__name__', '__main__')
+            except (AttributeError, ValueError):
+                return None
+        return module
+
+    def __repr__(cls):
+        return f"{cls.__name__}({', '.join(cls._fields)})"
+
+    def __new__(mcs, name, bases, attrs, fields: Sequence[str], defaults: Sequence = None, module=None):
+        module = NamedTupleMeta._find_module(module=module)
+        if NamedTupleI not in bases:
+            bases = (*bases, NamedTupleI)
+        bases = (*bases, collections.namedtuple(name, fields, defaults=defaults, module=module))
+        cls = super().__new__(mcs, name, bases, attrs)
+        cls.__module__ = module
+        return cls
+
+    def __init__(cls, name, bases, attrs, **_):
+        super().__init__(name, bases, attrs)
+
+
+def namedtuple(typename: str, fields: Sequence[str], defaults: Sequence = None, module=None):
+    """Wraps ``collections.namedtuple`` to add custom __repr__ for some data types:
+       numpy arrays, ...
+
+
+       **Additional manipulation over tuple content**
+
+       Extraction of part of the fields as a new tuple:
+
+        >>> v3 = namedtuple('XYZ', ['x', 'y', 'z'])(10, 20, 30)
+        >>> v3._part('z', 'x', name='ZX') == (v3.z, v3.x)
+        True
+        >>> v3._part(slice(0,2)) == v3[:2]
+        True
+        >>> v3._part(slice(0,2), slice(2,3)) == v3
+        True
+        >>> v3._part('x', slice(1,2), 2) == v3
+        True
+
+       Concatenation of tuples:
+
+        >>> v3._part('x', 'y') + v3._part('z') == v3
+        True
+
+    :param typename: name of the new type
+    :param fields: names of tuple fields in this order
+    :param defaults: sequence of default valued of the fields in same order
+    :param module: module the new class to be associated with
+    """
+    module = NamedTupleMeta._find_module(level=1, module=module)
+    return NamedTupleMeta(typename, bases=(), attrs={}, fields=fields, defaults=defaults, module=module)
+
+
+def name_tuple(typename='Tuple', **kws):
+    """
+    Create namedtuple OBJECT from name: value pairs
+
+    :param typename: for the tuple type
+    :param kws: names-values pairs
+    :return: namedtuple
+    """
+    return namedtuple(typename, tuple(kws.keys()))(*kws.values())
+
+
+def double_wrap(dec_func):
+    """
+    a decorator of decorator, allowing the decorator to be used as:
+    @decorator(with, arguments, and=kwargs)
+    or
+    @decorator
+    """
+
+    @wraps(dec_func)
+    def new_dec(*args, **kwargs):
+        if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+            # actual decorated function
+            return dec_func(args[0])
+        else:
+            # decorator arguments
+            return lambda real_func: dec_func(real_func, *args, **kwargs)
+
+    return new_dec
+
+
+class CaseInsEnum(str, enum.Enum):
+    """
+    Enum of string values allowing to set it with case-insensitive names or values.
+
+    >>> class E(CaseInsEnum):
+    ...     min: 'minimal'
+    ...     max: 'maximal'
+    ... assert E('Min') is E.min and E('MINIMAL') is E.min
+
+    Same can be also created functionally:
+
+    >>> E = CaseInsEnum('E', {'min': 'minimal', 'max': 'maximal'})
+
+    Or just list the keys if values are of no importance:
+
+    >>> En = CaseInsEnum('En', ['min', 'max'])
+    """
+    @classmethod
+    def _missing_(cls, key: str):
+        key = key.lower()
+        for n, v in cls._member_map_.items():
+            if n.lower() == key or isinstance(v, str) and v.lower() == key:
+                return v
+
+
+def enum_str_type(*values, name):
+    """
+    Create type enumerating provided strings as attributes AND values.
+
+    >>> Colors = enum_str_type('Colors', ['red', 'yellow'])
+    >>> assert Colors.yellow == Colors('yellow')
+
+    :param name:
+    :param values:
+    :return:
+    """
+    return CaseInsEnum(name, dict(zip(values, values)))
+
+
+def enum_attr(attr: str, **kwargs):
+    """Create ``CaseInsEnum`` class with an extra attribute for every member.
+
+    Examples
+    >>> AB = enum_attr('info', a='Member A', b='Member B')
+    >>> AB('a') is AB.a
+    True
+    >>> AB.b.info
+    'Member B'
+
+    Special attribute '__call__' is supported, to make the memebres callable by
+    providing each with its own function:
+
+    Examples
+    >>> Funcs = enum_attr('__call__', len=len, print=print)
+    >>> Funcs.len('Hi')
+    2
+    >>> Funcs.print('Hi')
+    Hi
+
+    :param attr: name of the attribute to add
+    :param kwargs: dict for all the members {name: attr_value}
+    """
+    class _EnumNameMatcher:
+        if attr == '__call__':
+            def __call__(self, *args, **kws):
+                return kwargs[self.name](*args, **kws)
+        else:
+            def __init__(self, m):
+                setattr(self, attr, kwargs[self.name])
+
+    return CaseInsEnum('EnumMatch', [*kwargs], type=_EnumNameMatcher)
+
+
+T = TypeVar("T")
+RT = TypeVar("RT")
+
+
+class classproperty(Generic[T, RT]):
+    """
+    Class property attribute (read-only).
+
+    This works around deprecation from 3.13 of
+    ::
+        class C:
+            @classmethod
+            @property
+            def some(cls,): ...
+
+    Same usage as @property, but taking the class as the first argument.
+    ::
+        class C:
+            @classproperty
+            def x(cls):
+                return 0
+
+        print(C.x)    # 0
+        print(C().x)  # 0
+    """
+
+    def __init__(self, func: Callable[[type[T]], RT]) -> None:
+        # For using `help(...)` on instances in Python >= 3.9.
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+        self.__name__ = func.__name__
+        self.__qualname__ = func.__qualname__
+        # Consistent use of __wrapped__ for wrapping functions.
+        self.__wrapped__: Callable[[type[T]], RT] = func
+
+    def __set_name__(self, owner: type[T], name: str) -> None:
+        # Update based on class context.
+        self.__module__ = owner.__module__
+        self.__name__ = name
+        self.__qualname__ = owner.__qualname__ + "." + name
+
+    def __get__(self, instance: Optional[T], owner: Optional[type[T]] = None) -> RT:
+        if owner is None:
+            owner = type(instance)
+        return self.__wrapped__(owner)
+

ialdev_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: ialdev-core
+Version: 0.1.0
+Summary: iad.core — algorithmic utilities: data tools, parameters, paths, caching, and more
+Author-email: Your Name <your.email@example.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: ialdev-io
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pyyaml>=5.4.0
+Requires-Dist: ruamel.yaml>=0.15.0
+Requires-Dist: regex>=2021.0.0
+Requires-Dist: rapidfuzz>=3.0
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: frozendict>=2.0.0
+Requires-Dist: python-box>=6.0.0
+Requires-Dist: joblib>=1.0.0
+Requires-Dist: configargparse>=1.0.0
+Requires-Dist: deprecated>=1.2.0
+Requires-Dist: semver>=2.13.0
+Requires-Dist: uncertainties>=3.1.0
+Requires-Dist: pint>=0.20.0
+Requires-Dist: zfpy
+Requires-Dist: xxhash>=3.0.0
+Requires-Dist: toolz>=0.11.0
+Requires-Dist: numba>=0.55.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: python-dotenv>=0.19.0
+Project-URL: Homepage, https://github.com/yourusername/toolbox
+Project-URL: Issues, https://github.com/yourusername/toolbox/issues
+Project-URL: Repository, https://github.com/yourusername/toolbox
+
+# algutils
+
+Algorithmic utilities: data tools, I/O, parameters, paths, caching, image transforms, and math (hist, geom, regress).
+
+Extracted from the toolbox project as a standalone, installable package.
+
+## Installation
+
+```bash
+# From this directory (editable)
+pip install -e .
+
+# With optional extras
+pip install -e ".[io,units,dev]"
+```
+
+## Usage
+
+```python
+from algutils import logger, as_list
+from algutils.param import TBox, YamlModel
+from algutils.io.format import FileFormat
+from algutils.io.imread import imread
+```
+
+## Development
+
+- **pixi**: `pixi install` then `pixi run test` or `pixi run lint`
+- **pip**: `pip install -e ".[dev]"` then `pytest src/algutils -v`
+

ialdev_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+iad/core/__init__.py,sha256=4xggwbL5Zndz_oFrfs219c6P8efWRrEWnUDeP2bXhIA,149
+iad/core/array.py,sha256=O_zxRbaucDW2Q7eEx5ARajw2lHJYpz1dvC1jxQ4RmlU,79170
+iad/core/binary.py,sha256=vWVobeuAx7EHLqLM0RM04bWLJvZrVGTheEEYHd7N-Kc,13114
+iad/core/cache.py,sha256=put1jCyjHa6T6ADYnJbtG4TBwe9atsH7dLO6pi1AD4k,32377
+iad/core/codetools.py,sha256=Id9FKG8fCpaaueg3Jvc0p809BDVHBP5aW7QBeQs2fkg,6355
+iad/core/datatools.py,sha256=CuTQs1C46wAipG9W0NtW2UztczQ2xNWjCv2nRPJnSuU,24314
+iad/core/dotstyle.py,sha256=8gvL-whoezSmkHvDjfR9DofGHygsEhIQrNdSi_sCVCs,3226
+iad/core/env.py,sha256=Kg84m5BDqvZG9me0xKgpnjJJV89TiAhErWXCuN4G6VQ,11259
+iad/core/events.py,sha256=TWxAVKmUWae7EF3OdR1vQ2FksSzpBMWpxy8X7HPn-yQ,25296
+iad/core/filesproc.py,sha256=l-vfMj4t6TyIVSmtU0bPWhsFYvnpxlL4YHHg18kpY8s,40292
+iad/core/fnctools.py,sha256=xt6UX9O4cUlK7UdG3m7mmAgQXwpWF16zRbNLZ-yWKy4,13157
+iad/core/label.py,sha256=WDB9syfugJ3WC4Xy42WeICi9lX9ADRradboqEn8Bhx8,8780
+iad/core/logs.py,sha256=XO0jykx7ryr2VPX1pap_On3Da7hM9PzBGmayD_wHpK0,5973
+iad/core/nptools.py,sha256=PoHzObTQ9JKRdgbZNeYJBSksu33tjG3A5f7o4fqk1D0,13435
+iad/core/one_dark.puml,sha256=UPosFuJLYw460MLlYckuwUn79rZI1u6Uac7GsxPl_GA,17513
+iad/core/paths.py,sha256=16cCCiUtRW4RLAY6RJVkOUDYNTNYwWKM4yv-bbx4sFc,22076
+iad/core/pdtools.py,sha256=cRpEtzCQLbzTLmmmweJS77Gw820Hiluss_BqG1Ojyv0,104952
+iad/core/regexp.py,sha256=I66EqUAZcKgy21uJY82w7oUsMII27MgGCZz6znVGKM4,12804
+iad/core/short.py,sha256=NrSDmte61g_8qcsQV0x6hoWOqZcqTGcTrWW2_1449yM,9942
+iad/core/strings.py,sha256=XhYgQZwS_aTbyUOHY--1XQPNHz_HPkLMuumj0t0bLoc,21743
+iad/core/unc_panda.py,sha256=S5S5__BQb93b-tLOk9MAyxgCz0cqOtrL7FY8mvFFTpY,8916
+iad/core/units.py,sha256=dKfP__EDbZUDaIL46u91t29JXlig74k09rJbMCyemZs,1842
+iad/core/wrap.py,sha256=B3I0b6PxuXyE2JenIaoDCmXYocGuaFmUD4JfdlIvwco,14193
+iad/core/docs/locators.ipynb,sha256=fCqTraIJU4tm52I6mLXgjs-piX6zf74XjTRCj-PEwoA,17402
+iad/core/param/__init__.py,sha256=gXKFYSJx8q9AFc8X4W_S5cCPNAcIPmreN7sFuMo9uDM,623
+iad/core/param/confargparse.py,sha256=OO-bnGgErJNvlZEPAj6_4jnR57edtw1FIJRd0ihWKi4,2326
+iad/core/param/paramaze.py,sha256=iMuaoyRx8gOXI-kRASYsQnCN0bcHC9JWNJhLDEqVZLc,14411
+iad/core/param/tbox.py,sha256=UzumsGhBK73itUqu9Hl-qhRAQwm8YT5dADapJxSh65M,10665
+iad/core/pydantools/__init__.py,sha256=3tQHBGtqP460FHWMjWfT2HEIXbSVxZuxnVtvaVI5i1g,230
+iad/core/pydantools/models.py,sha256=Oqk-Cd82vHa4FHsLbvOgP3Cupcf-Q8rVuPo25s40BMQ,21955
+iad/core/pydantools/fixed_pydantic_yaml/__init__.py,sha256=7RZILZOdH_mHDQyIDC1bN1LmM1qNGTajVH1rp2_nKds,531
+iad/core/pydantools/fixed_pydantic_yaml/main.py,sha256=NCRUz-MFYtiPx5RrZYJar4jig4ZZUnzMWrfZIx16uyo,774
+iad/core/pydantools/fixed_pydantic_yaml/mixin.py,sha256=OmS05ME0JkzFx9eM39P04TlvruDHHme9jN2UyQnPIow,9741
+iad/core/pydantools/fixed_pydantic_yaml/model.py,sha256=5soCAJQdwMec5OOSjU59mzMJHbbW7QGI6drYwNo0oRQ,569
+iad/core/pydantools/fixed_pydantic_yaml/py.typed,sha256=DtCsIDq6KOv2NOEdQjTbeMWJKRh6ZEL2E-6Mf1RLeMA,59
+iad/core/pydantools/fixed_pydantic_yaml/version.py,sha256=H9NWRZb7NbeRRPLP_V1fARmLNXranorVM-OOY-8_2ug,22
+iad/core/pydantools/fixed_pydantic_yaml/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iad/core/pydantools/fixed_pydantic_yaml/compat/hacks.py,sha256=0Bta3tgEsABwne7H0QdwN_d46wiMM25c83nAoE2YKxo,2087
+iad/core/pydantools/fixed_pydantic_yaml/compat/old_enums.py,sha256=cjGmmS3sGHFMH0pHd82JsZHdZfmFhknnY1fq_EInIUU,963
+iad/core/pydantools/fixed_pydantic_yaml/compat/representers.py,sha256=kWJtC5GUrrOGSMxNRtJkPWxVVu-dQX62zEQT1LeVor0,2480
+iad/core/pydantools/fixed_pydantic_yaml/compat/types.py,sha256=knTZj52933YRhFtW69_hd4ubAlxe3njrdyOipr9Qp6o,3611
+iad/core/pydantools/fixed_pydantic_yaml/compat/yaml_lib.py,sha256=RZoLqOh-p0qoVbIs8DdgGCc6HjDCKsTphnZG72f6nWA,3245
+iad/core/pydantools/fixed_pydantic_yaml/ext/__init__.py,sha256=N3F4AH6kyPV8n40LKvteU1EvR5CC_gvbR92AGtaaAPs,81
+iad/core/pydantools/fixed_pydantic_yaml/ext/semver.py,sha256=31jPcdu9A99_rMoEAKCWfzSW46ellcEhnO9Zj4h34Mc,4164
+iad/core/pydantools/fixed_pydantic_yaml/ext/versioned_model.py,sha256=jdqMTs15XoiV8MTTFonPNB-dNuZ_bCsCKKeDFmKlPqI,3507
+ialdev_core-0.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+ialdev_core-0.1.0.dist-info/METADATA,sha256=SWtY7F9cXXPzD8_aZ8dYgmMDYIrsmbZZTPYREUVXAQY,2278
+ialdev_core-0.1.0.dist-info/RECORD,,

ialdev_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any