immlib 1.0.0.dev2__py3-none-any.whl

immlib/workflow/_plantype.py

@@ -0,0 +1,334 @@
+# -*- coding: utf-8 -*-
+###############################################################################
+# immlib/workflow/_plantype.py
+
+
+# Dependencies ################################################################
+
+import inspect
+from functools import wraps
+from copy import copy
+
+from pcollections import (pdict, ldict, lazy)
+
+from ..doc import docwrap
+from ..util import (is_str, is_pdict, is_tdict, is_ldict, assoc, merge)
+from ._core import (calc, plan, plandict, tplandict, is_calcfn)
+
+
+# #plantype ###################################################################
+
+class plantype(type):
+    """A metaclass that allows one to create lazy types from calculation plans.
+
+    The ``plantype`` metaclass handles classes with the base-class
+    ``planobject``.  In general, one should create a plan-object by inheriting
+    from ``planobject``, not by providing the ``plantype`` metaclass, but
+    passing ``plantype`` has the same effect (all classes created with
+    metaclass ``plantype`` will inherit from ``planobject``).
+
+    See ``planobject`` for more information.
+    """
+    __slots__ = ()
+    class planobject_base:
+        """The base-class for the ``immlib.planobject`` class.
+
+        ``plantype.planobject_base`` is a simple class that implements the
+        basic features of the ``planobject`` class. The separation for certain
+        methods from the ``planobject`` type itself is required due to details
+        of how the ``planobject`` class, which has the ``plantype`` meta-class,
+        gets initialized while the ``plantype.__new__`` method depends on
+        methods in the ``planobject`` class (which hasn't been
+        initialized/defined at the time that the ``planobject.__new__`` method
+        is called. This class shouldn't be used directly and shouldn't be
+        inherited. Use the ``planobject`` class instead.
+        """
+        __slots__ = ('_plandict_',)
+        def __getattr__(self, k):
+            pd = self._plandict_
+            r = pd.get(k, pd)
+            if r is pd:
+                raise AttributeError
+            else:
+                return r
+        def __setattr__(self, k, v):
+            pd = self._plandict_
+            pdtype = type(pd)
+            plan = type(self).plan
+            if pdtype is dict or pdtype is tplandict:
+                if k not in plan.inputs:
+                    msg = "only planobject inputs may be mutated in "
+                    if pdtype is dict:
+                        msg += "the __init__ method"
+                    else:
+                        msg += "transient planobjects"
+                    raise ValueError(msg)
+                else:
+                    pd[k] = v
+            else:
+                raise TypeError(f"type {type(self)} is immutable")
+        def __delattr__(self, k):
+            pd = self._plandict_
+            if type(pd) is dict:
+                raise TypeError(
+                    f"cannot delete attributes from plantype: {type(self)}")
+            else:
+                raise TypeError(f"type {type(self)} is immutable")
+        def __new__(cls, *args, **kwargs):
+            # Start by creating the object itself and setting up its slots.
+            obj = object.__new__(cls)
+            object.__setattr__(obj, '_plandict_', None)
+            # Once the __init__ function is done running, the plandict will be
+            # cleaned up (this is guaranteed by the plantype meta-class).
+            return obj
+        def __dir__(self):
+            pd = self._plandict_
+            l = object.__dir__(self)
+            l.extend(pd.keys())
+            l.sort()
+            return l
+        def __init__(self, *args, **kwargs):
+            for (k,v) in merge(*args, **kwargs).items():
+                setattr(self, k, v)
+        @staticmethod
+        def _init_wrapper(cls, self, *args, **kwargs):
+            """Manages the initialization (``__init__``) for ``planobject``
+            types.
+
+            The ``planobject`` type, and any types that inherit from it, is
+            generally immutable; however, When a ``planobject`` is first
+            created, it is allowed to set its inputs, as if they were mutable
+            attributes, during the ``__init__()`` method. In order to
+            facilitate this, a reorganization of the initialization code for
+            each ``planobject`` subclass is performed when that class is
+            defined. The class's true ``__init__`` method is stored in the
+            method ``__planobject_init__``, while the
+            ``plantype.planobject_base._init_wrapper`` method is stored in the
+            type's ``__init__`` method. This method calls the type's
+            ``__planobject_init__`` method then makes the initialized object
+            immutable.
+
+            This method should not be called directly by the user.
+            """
+            # If the plandict is not a mutable dictionary, we have already been
+            # initialized.
+            pd = self._plandict_
+            if is_pdict(pd) or is_tdict(pd):
+                raise RuntimeError(
+                    "_init_wrapper method called on an already-initialized"
+                    " planobject")
+            elif pd is not None:
+                # We're already in the middle of initializing; one of the
+                # __init__ methods probably just called a parent class's
+                # __init__ method. We can just run it and return.
+                return cls.__planobject_init__(self, *args, **kwargs)
+            # Otherwise, pd is None, meaning that we're the first initializer.
+            # Note that we are now in the process of initializing...
+            pd = {}
+            object.__setattr__(self, '_plandict_', pd)
+            # This method is the real initializer for the class (what the
+            # class's actual code wrote as the __init__ method).
+            cls.__planobject_init__(self, *args, **kwargs)
+            # Postprocess the argument.
+            theplan = type(self).plan
+            params = dict(theplan.defaults, **pd)
+            if params.keys() != theplan.inputs:
+                raise ValueError(
+                    f"bad parameters for plantype {type(self)};"
+                    f" expected {tuple(theplan.inputs)} but found"
+                    f" {tuple(params.keys())}")
+            pd = theplan(params)
+            object.__setattr__(self, '_plandict_', pd)
+        # For the pickle module:
+        def __getstate__(self):
+            return dict(self._plandict_.inputs)
+        def __setstate__(self, inputs):
+            plan = type(self).plan
+            object.__setattr__(self, '_plandict_', plan(inputs))
+    def __new__(cls, name, bases, attrs, **kwargs):
+        sup = super(plantype, cls)
+        # Before we go too far, let's extract the valid args from kwargs.
+        initplan = kwargs.pop('plan', None)
+        inittrans = kwargs.pop('transient', False)
+        if len(kwargs) > 0:
+            ks = tuple(kwargs.keys())
+            raise ValueError(f"unsupported type options: {ks}")
+        # We want to go over the attributes and make a few changes:
+        # (1) We want to make the basic updates.
+        kvs = [
+            ('__getattr__', plantype.planobject_base.__getattr__),
+            ('__setattr__', plantype.planobject_base.__setattr__),
+            ('__new__',     plantype.planobject_base.__new__),
+            ('__dir__',     plantype.planobject_base.__dir__)]
+        for (k,v) in kvs:
+            if k in attrs:
+                raise ValueError(f"plantype classes may not define {k}")
+            else:
+                attrs[k] = v
+        # (2) We want to save the init function and update it to our version.
+        init = attrs.get('__init__', plantype.planobject_base.__init__)
+        attrs['__planobject_init__'] = init
+        def _initfn(self, *args, **kwargs):
+            return plantype.planobject_base._init_wrapper(
+                _initfn.cls, self, *args,
+                **kwargs)
+        attrs['__init__'] = wraps(init)(_initfn)
+        # (3) Go through the bases: see if there are planobject bases already,
+        #     and if not, add planobject in. As we go, collect calculations.
+        calcs = {k:v for (k,v) in attrs.items() if is_calcfn(v)}
+        found_planobj = False
+        for b in bases:
+            if not issubclass(b, plantype.planobject_base): continue
+            found_planobj = True
+            for (k,v) in inspect.getmembers(b):
+                if k not in calcs and is_calcfn(v):
+                    calcs[k] = v
+        if not found_planobj:
+            bases.append(plantype.planobject_base)
+        # (4) We now want to create the plan from these calculations and make
+        #     sure it's part of the class.
+        if initplan is None:
+            attrs['plan'] = plan(calcs)
+        else:
+            attrs['plan'] = plan(initplan, **calcs)
+        # (5) Return the type with all the updated attributes.
+        cls = sup.__new__(cls, name, bases, attrs)
+        _initfn.cls = cls
+        return cls
+
+
+# #planobject #################################################################
+
+class planobject(plantype.planobject_base, metaclass=plantype):
+    """Base class for objects that are based on lazy calculation plans.
+
+    ``planobject`` is the base-class for all objects that use ``immlib.plan``
+    objects as their base type. Objects that inherit from ``planobject`` (which
+    uses metaclass ``plantype``) are defined in the same way that calculation
+    plans are defined. Any attributes of the class (including those inherited
+    from base classes) that are calculations (see ``immlib.calc`` and
+    ``immlib.plan``) are turned into a plan. The inputs of the plan are the
+    required parameters for the class, and the outputs of the plan become the
+    attributes of the class, which are resolved lazily like in ``plandict`` s.
+
+    The ``__init__`` function of a ``planobject`` is special. During the
+    ``__init__`` function only, the parameters of a ``planobject`` function can
+    be set using the usual ``setattr`` interface. All ``planobject``s are
+    immutable once they have been initialized, however. At the end of the
+    ``__init__`` function, the object must have all of its parameters set,
+    otherwise an error is raised. If no ``__init__`` function is defined, then
+    the ``planobject`` default init function calls ``merge`` on its arguments
+    and keywords; the resulting dict must be a dictionary of the class's
+    parameters.
+
+    ``planobject`` types must not overload the following methods, as they are
+    used by the ``planobject`` / ``plantype`` system. These are:
+    * ``__new__``
+    * ``__setattr__``
+    * ``__getattr__``
+    * ``__dir__``
+    """
+    __slots__ = ()
+    def __str__(self):
+        pd = object.__getattribute__(self, '_plandict_')
+        p = pd.plan
+        param_str = ", ".join(
+            f"{k}={pd[k] if pd.is_ready(k) else '<lazy>'}"
+            for k in p.inputs)
+        rest_str = ", ".join(
+            f"{k}={pd[k] if pd.is_ready(k) else '<lazy>'}"
+            for k in p.outputs if not k.startswith('_'))
+        cls = type(self)
+        if rest_str:
+            return f"{cls.__name__}({param_str}; {rest_str})"
+        else:
+            return f"{cls.__name__}({param_str})"
+    def __repr__(self):
+        pd = object.__getattribute__(self, '_plandict_')
+        p = pd.plan
+        param_str = ", ".join(
+            f"{k}={pd[k]}" for k in p.inputs)
+        rest_str = ", ".join(
+            f"{k}={repr(pd.getlazy(k))}" for k in p.outputs)
+        cls = type(self)
+        if rest_str:
+            return f"{cls.__module__}.{cls.__name__}({param_str}; {rest_str})"
+        else:
+            return f"{cls.__module__}.{cls.__name__}({param_str})"
+    def __eq__(self, other):
+        if type(self) is not type(other):
+            return False
+        return self._plandict_.inputs == other._plandict_.inputs
+    def __ne__(self, other):
+        if type(self) is not type(other):
+            return True
+        return self._plandict_.inputs != other._plandict_.inputs
+    def __hash__(self):
+        return hash((type(self), self._plandict_.inputs))
+    def copy(self, **kwargs):
+        """Creates a copy of the planobject with optional parameter updates.
+        """
+        pd = plandict(self._plandict_, **kwargs)
+        obj = object.__new__(self.__class__)
+        object.__setattr__(obj, '_plandict_', pd)
+        return obj
+    def transient(self):
+        """Returns a transient copy of the planobject."""
+        pd = self._plandict_
+        if pd is None or isinstance(pd, dict):
+            raise RuntimeError(
+                f"cannot create transient copy during initialization")
+        c = copy(self)
+        object.__setattr__(c, '_plandict_', tplandict(pd))
+        return c
+    def persistent(self):
+        """Returns a persistent copy of the planobject. If the planobject is
+        already persistent, it is returned unchanged.
+        """
+        pd = self._plandict_
+        if pd is None or isinstance(pd, dict):
+            raise RuntimeError(
+                f"cannot create persistent copy during initialization")
+        elif isinstance(pd, plandict):
+            # Already persistent.
+            return self
+        elif not isinstance(pd, tplandict):
+            raise ValueError(f"unknown plandict type: {type(pd)}")
+        c = copy(self)
+        object.__setattr__(c, '_plandict_', pd.persistent())
+        return c
+    def is_persistent(self):
+        """Returns ``True`` if the planobject is persistent and ``False`` if it
+        is transient.
+        """
+        pd = self._plandict_
+        if pd is None or isinstance(pd, dict):
+            return type(self).init_transient
+        else:
+            return isinstance(pd, plandict)
+
+
+# Utilities ###################################################################
+
+@docwrap
+def is_planobject(obj):
+    '''Determines if an object is an instance of a ``immlib.plantype`` object.
+    
+    ``is_planobject(obj)`` returns ``True`` if ``obj`` is an instance of a
+    ``immlib.plantype`` class and ``False`` otherwise.
+
+    See also: ``plantype``, ``is_plantype``
+    '''
+    return isinstance(obj, planobject)
+@docwrap
+def is_plantype(obj):
+    '''Determines if an object is a ``immlib.plantype``.
+    
+    ``is_plantype(obj)`` returns ``True`` if ``obj`` is a ``immlib``
+    ``plantype`` class and ``False`` otherwise. Note that this works for the
+    type but not instances of the type, for which you should use
+    ``is_planobject``.
+
+    See also: ``is_planobject``, ``plantype``
+    '''
+    return isinstance(obj, plantype)

immlib-1.0.0.dev2.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: immlib
+Version: 1.0.0.dev2
+Summary: A library of utilites for immutable scientific data.
+Author-email: "Noah C. Benson" <nben@uw.edu>
+License: MIT
+Project-URL: homepage, https://github.com/noahbenson/immlib
+Project-URL: documentation, https://github.com/noahbenson/immlib
+Project-URL: repository, https://github.com/noahbenson/immlib
+Keywords: persistent,immutable,functional,scientific,workflow
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pcollections>=0.3.2
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: pint>=0.20.0
+Requires-Dist: docrep>=0.3.2
+Requires-Dist: joblib>=1.3.0
+Requires-Dist: cloudpathlib[azure,gs,s3]>=0.18.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: torch>=2.2.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: torch>=2.2.0; extra == "test"
+Provides-Extra: docs
+Requires-Dist: torch>=2.2.0; extra == "docs"
+Requires-Dist: jupyter-book>=1.0.0; extra == "docs"
+Requires-Dist: matplotlib>=3.4.0; extra == "docs"
+Dynamic: license-file
+
+![immlib](https://noahbenson.github.io/immlib/_static/logo.svg "immlib")
+
+![Build Status](https://github.com/noahbenson/immlib/actions/workflows/tests.yml/badge.svg)
+[![codecov](https://codecov.io/gh/noahbenson/immlib/graph/badge.svg?token=8KO3K6DUX4)](https://codecov.io/gh/noahbenson/immlib)
+[![PyPI version](https://badge.fury.io/py/immlib.svg)](https://badge.fury.io/py/immlib)
+
+---
+
+**Author**: Noah C. Benson &lt;[nben@uw.edu](mailto:nben@uw.edu)&gt;  
+**License**: MIT  
+**[Documentation](https://noahbenson.github.io/immlib)**
+
+---
+
+`immlib` is a lightweight Python library that simplifies the design of
+application programming interfaces (APIs) for scientific libraries. The name
+immlib comes from the library’s philosophy of using immutable data to simplify
+scientific workflows.
+
+`immlib` is heavily based on the library
+[`pimms`](https://github.com/noahbenson/pimms), which effectively served as a
+prototype for `immlib`. Both libraries were motivated by a number of observations
+about the design of scientific software and are an attempt to make some of these
+problems easier to manage.
+
+For more information, see the [documentation](https://noahbenson.github.io/immlib).

immlib-1.0.0.dev2.dist-info/RECORD

@@ -0,0 +1,45 @@
+immlib/__init__.py,sha256=fecv8u3tjOwKH4QEzbEoMzZM9ujg7HGf5whbiSG2_Ho,5172
+immlib/_init.py,sha256=iKUNLoI78R7TdT5tp4zofOauTSgFrYfkRyrpbBiaDVU,4836
+immlib/_version.py,sha256=K35pXPrOxntfy7H7G7zEct0zT4rR7fY1kOdLeveAiK8,9735
+immlib/doc/__init__.py,sha256=oBumAnslnULXFYGCPFfe300juR0kYOs2Sg_yVjoW30w,1583
+immlib/doc/_core.py,sha256=8zqulVeRLMkbsiqxuJA9wcvSZC-1UMxjx6P36gZL5BY,12363
+immlib/iolib/__init__.py,sha256=VKXix_P56CYq9PzRYa3zdfnCG704rAuG5U5gcxiyJ5I,732
+immlib/iolib/_core.py,sha256=Ccbq210K0ZOr26aae9W090wyei6mBwJblpn70HNH0ds,29779
+immlib/pathlib/__init__.py,sha256=oH4vA4qlGvVXJZGV5i_1R9s-QgFtymZV-ouhgdNixMw,1532
+immlib/pathlib/_cache.py,sha256=7enOW6hyr9lk_QpGucUdF1QMTtRN5zUkSZVk4HNkYAM,6457
+immlib/pathlib/_core.py,sha256=8pQFDtDYBnveMXn8EEESbDC1lhnpqL-cC891rznkiQk,33104
+immlib/pathlib/_osf.py,sha256=v9SRouin1nsnIVwtvNcOIysAbWF3HuQY1tw2CPhqOn0,23157
+immlib/test/__init__.py,sha256=jQUoerBEmIrZU0k3lcDueL3I2MucqtBTug0xS-4Pvz0,422
+immlib/test/__main__.py,sha256=2dVA5jVU-8Nz6JuECZfAxOpmvAAOeCNhur0mHgBCMcE,326
+immlib/test/doc/__init__.py,sha256=Ne7qgHidq6_-77vFb73M3-TIWHxo9m550ayg-b_G20E,183
+immlib/test/doc/test_core.py,sha256=poLHtPVHGt5hjIpTSy_J6sAN4LiA37WDB3y3hIK1LaE,3317
+immlib/test/iolib/__init__.py,sha256=k17eFvA2NVB-nlRkvc7eqOb13qhg0js5QQHHnWejd3U,204
+immlib/test/iolib/test_core.py,sha256=N1w_XbPXJLnX39_RRx4YqSo-QJso5tuu3p5jAmXp6Zw,3246
+immlib/test/pathlib/__init__.py,sha256=fztC586ptuFNVYUqhGmMDGH4QiUPZfZCC169bjT7v5Q,285
+immlib/test/pathlib/test_core.py,sha256=0oq8L-xlZtgkgCbNOrkm5YNOVK0OHAUXjckE7EAayk0,6251
+immlib/test/pathlib/test_osf.py,sha256=_nc880p41bz8g7_UmWVFCPbraacIMzNi6oFgMC7Zqyw,1980
+immlib/test/types/__init__.py,sha256=rjdFsszZ1o3h5X6bicGQYFhkJ6S7yzZKsRcwkHdmhEY,176
+immlib/test/types/test_core.py,sha256=kMQ9M6GxMHLSYsY8YpD3Pn6IMPB_d7NDMSZ3CZV1Sog,4546
+immlib/test/util/__init__.py,sha256=g7PJ2azOhPEGm6O_VwvSRiSbvOi84L4qJSho3etkkCY,344
+immlib/test/util/test_core.py,sha256=OP62KnR_DBpHVp7mqc3gYjQhLlDbqfZE8UYVq_Vqdgo,30410
+immlib/test/util/test_numeric.py,sha256=8ZMm8d5o1A8u7hV_jqViAypXZ0seV7dpQE6nAAhP2jo,69693
+immlib/test/util/test_quantity.py,sha256=WGhmTOgriERj099erRAMQ00geQBirRsiwjJ7Tv6iqJk,10528
+immlib/test/util/test_url.py,sha256=27nj07zdHLPkWrETUgfAhn_r9FBBh8E99q_phrY_tIk,1953
+immlib/test/workflow/__init__.py,sha256=ADNWqVFMf-HJeLlr-yMjLVTVAkokDIo1g9FOAyZ552A,275
+immlib/test/workflow/test_core.py,sha256=Jz-DmiNBN9OWMhlpXfpk9rlnsZBepz4f8ebkBvbZcag,19684
+immlib/test/workflow/test_plantype.py,sha256=zCr4_D7heoaK3p_4QKWaZfvFdqHqHURL8z_-7XjOZeA,9507
+immlib/types/__init__.py,sha256=1io0pYlD8qGbl5oxC62TXImi374QGp1Ie4nkOjepNdo,786
+immlib/types/_core.py,sha256=KOMrwG2gnAk634wvu7cPgdyvAjGsMUfV2QOTNEuRn4I,12894
+immlib/util/__init__.py,sha256=jLIybcflDJzu6J-Ow4CzQfhLIqm1jPS3P6QvUfr2SJ0,5056
+immlib/util/_core.py,sha256=X5ZZJCa41G-9vbR-Y-ccQmt-JftsTqf_v175gKU2tvQ,86895
+immlib/util/_numeric.py,sha256=UEtaOGsDo3ac4utI98zzp8_t4fRSakFc9UIRXEYILXY,109774
+immlib/util/_quantity.py,sha256=Y5uEOzuVjyqFZ0mKaAVu2NA02TQljxbYW3dUx9pWBYY,19704
+immlib/util/_url.py,sha256=HXZ7e_DwvZclBf8GxmQXptPytTX7jUH8RatpTXOJU8E,4414
+immlib/workflow/__init__.py,sha256=eKln38YHuI2yyduSgO3tuk-QNlUdqiqDTT2ikJZcN3c,1065
+immlib/workflow/_core.py,sha256=Dufeh9DdyQt4XSGwF0ItB_9KybU_6OVQkjA7EKOEGHs,72939
+immlib/workflow/_plantype.py,sha256=Q6tFqPmCUt9KblwfgGGWgdZCnZLn4KSzak7yK47RFu0,14595
+immlib-1.0.0.dev2.dist-info/licenses/LICENSE,sha256=SmSO0nCJkuibrAEOAuq8HNUn6SJ52Pk_NQ2bf7HHw-g,1071
+immlib-1.0.0.dev2.dist-info/METADATA,sha256=jMek4toNqYFpgZiQj-HK30LTDKjGUrWeOb14D_Pelk4,3216
+immlib-1.0.0.dev2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+immlib-1.0.0.dev2.dist-info/top_level.txt,sha256=xZpW_wIFaEUjhV4ZcdIsyDupd1RZKv43W3XV8frCkUk,7
+immlib-1.0.0.dev2.dist-info/RECORD,,

immlib-1.0.0.dev2.dist-info/WHEEL

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

immlib-1.0.0.dev2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Noah C. Benson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

immlib-1.0.0.dev2.dist-info/top_level.txt

@@ -0,0 +1 @@
+immlib