stranded 0.0.1__py3-none-any.whl

stranded/types/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import importlib as _importlib
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+    from . import convert
+    from .convert import Convert
+
+
+def __getattr__(name: str) -> _typing.Any:
+    match name:
+        case 'convert': return _importlib.import_module('.convert', __name__)
+        case 'Convert': return _importlib.import_module('.convert', __name__).Convert
+        case _: raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = (
+    'convert',
+    'Convert',
+)

stranded/types/constraint.py

@@ -0,0 +1,7 @@
+import dataclasses
+import typing
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Constraint[T]:
+    _assert: typing.Callable[[T], bool]

stranded/types/convert.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import ast
+import builtins
+import dataclasses
+import enum
+import types
+import typing
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Convert[T]:
+    """Converts a given str argument into given type T.
+
+        >>> assert Convert(t=dict[int, str])('{42: "foo"}') == {42: "foo"}
+        >>> assert Convert(t=typing.Literal['foo', 'bar', 'baz'])('"foo"') == "foo"
+        >>> assert Convert(t=int | float | str)('3.14') == 3.14  # noqa
+        >>> assert Convert(t=tuple[int, ...])('(1, 2, 3, 4)') == (1, 2, 3, 4)
+
+    This performs verification that the arg matches the given type.
+
+        >>> assert ast.literal_eval('3.14') == 3.14
+        >>> Convert(t=int)('3.14') == 3.14
+        Traceback (most recent call last):
+          ...
+        ValueError: Could not convert arg=3.14 to t=<class 'int'>.
+
+    Custom types may also be used. The underlying type must be trivially-costructable with the output of
+    ast.literal_eval of given positional constructor arg.
+
+        >>> class MyEnum(enum.Enum):
+        ...     foo = 1
+        ...     bar = 2
+        ...     baz = 3
+        >>> assert Convert(t=MyEnum)('foo') == MyEnum.foo
+
+        >>> @dataclasses.dataclass(frozen=True)
+        ... class Foo[T]:
+        ...     v: T
+        >>> assert Convert(t=Foo)('foo') == Foo('foo')
+        >>> assert Convert(t=Foo[str])('foo') == Foo('foo')
+
+    Custom type aliases may be used similarly to custom types. The type alias arguments must correspond to the types of
+    given positional constructor arguements.
+
+        >>> @dataclasses.dataclass(frozen=True)
+        ... class Bar[T, U, V]:
+        ...     a: T
+        ...     b: U
+        ...     c: V
+        >>> assert Convert(t=Bar[int, float, Foo])('42, 3.14, "foo"') == Bar(42, 3.14, Foo('foo'))
+        >>> assert Convert(t=Bar[str, Foo[str], Foo[MyEnum]])('"foo", "foo", "foo"') == Bar("foo", Foo("foo"), Foo(MyEnum.foo))
+    """
+    t: type[T]
+
+    type _Args = bool | float | int | str | list[typing.Any] | dict[typing.Any, typing.Any] | set[typing.Any] | None
+
+    def _using_type(self, arg: _Args, /) -> T:
+        match self.t:
+            case types.NoneType | None:
+                assert arg is None, f'{self} expected `None`, got `{arg}`.'
+                return arg  # type: ignore[return-value]
+            case builtins.bool | builtins.int | builtins.float | builtins.str:
+                assert isinstance(arg, self.t), f'{self} expected `{self.t}`, got `{arg}`'
+                return arg
+            case t if issubclass(t, enum.Enum):
+                assert isinstance(arg, str) and hasattr(t, arg), (
+                    f'{self} expected `{typing.Literal[*t._member_names_]}`, got `{type(arg)}`'  # noqa
+                )
+                return getattr(t, arg)  # type: ignore[no-any-return]
+            case t:
+                return t(arg)  # type: ignore[call-arg]
+
+    def _using_type_alias(self, args: _Args, /) -> T:
+        match typing.get_origin(self.t), typing.get_args(self.t):
+            case builtins.dict, (key_t, value_t):
+                assert isinstance(args, dict), (
+                    f'{self} expected `dict[{key_t}, {value_t}]`, got `{args}`'
+                )
+                return {  # type: ignore[return-value]
+                    Convert(t=key_t)._from_arg(key): Convert(t=value_t)._from_arg(value)
+                    for key, value in args.items()
+                }
+
+            case builtins.frozenset, (t,):
+                assert isinstance(args, (set, frozenset)), (
+                    f'{self} expected `{frozenset[t]}`, got `{args}`.'  # type: ignore[valid-type]
+                )
+                return frozenset({Convert(t=t)._from_arg(arg) for arg in args})  # type: ignore[return-value]
+
+            case builtins.list, (t,):
+                assert isinstance(args, list), (
+                    f'{self} expected `{list[t]}`, got `{args}`.'  # type: ignore[valid-type]
+                )
+                return list(Convert(t=t)._from_arg(arg) for arg in args)  # type: ignore[return-value]
+
+            case builtins.tuple, ():
+                assert args == tuple(), (  # type: ignore[comparison-overlap]
+                    f'{self} expected `{tuple[()]}`, got `{args}`.'
+                )
+                return args  # type: ignore[return-value]
+            case builtins.tuple, (t,):
+                assert isinstance(args, tuple) and len(args) == 1, (
+                    f'{self} expected `{tuple[t]}`, got `{args}`.'  # type: ignore[valid-type]
+                )
+                return tuple([Convert(t=t)._from_arg(args[0])])
+            case builtins.tuple, (t, builtins.Ellipsis):
+                assert isinstance(args, tuple), (
+                    f'{self} expected `{tuple[t, ...]}`, got `{args}`.'  # type: ignore[valid-type]
+                )
+                return tuple([Convert(t=t)._from_arg(value) for value in args])
+            case builtins.tuple, (t, *ts):
+                assert isinstance(args, tuple) and len(args) > 0, (
+                    f'{self} expected `{tuple[t, *ts]}`, got `{args}`.'  # type: ignore[valid-type]
+                )
+                return Convert(t=t)._from_arg(args[0]), *Convert(t=tuple[*ts])._from_arg(args[1:])  # type: ignore[valid-type]
+
+            case builtins.set, (t,):
+                assert isinstance(args, (set, frozenset)), (
+                    f'{self} expected `{set[t]}`, got `{args}`.'  # type: ignore[valid-type]
+                )
+                return set({Convert(t=t)._from_arg(arg) for arg in args})  # type: ignore[return-value]
+
+            case(typing.Union | types.UnionType), ts:
+                assert type(args) in ts, (
+                    f'{self} expected `{typing.Union[*ts]}`, got `{args}`.'
+                )
+                return args  # type: ignore[return-value]
+            case typing.Literal, vs:
+                assert args in vs, (
+                    f'{self} expected `{typing.Literal[*vs]}`, got `{args}`.'  # noqa
+                )
+                return args  # type: ignore[return-value]
+
+            case t, (t_,):
+                return t(Convert(t=t_)._from_arg(args))  # type: ignore[misc, no-any-return]
+            case t, ts:
+                return t(*(Convert(t=t)._from_arg(arg) for t, arg in zip(ts, args)))  # type: ignore[arg-type, misc, no-any-return]
+
+
+    def _from_arg(self, arg: _Args, /) -> T:
+        return self._using_type(arg) if typing.get_origin(self.t) is None else self._using_type_alias(arg)
+
+    def __call__(self, arg: str, /) -> T:
+        """Returns a T from given arg. Raises ValueError upon failure."""
+
+        if self.t != str:
+            try:
+                arg: Convert._Args = ast.literal_eval(arg)  # type: ignore[no-redef]
+            except (SyntaxError, ValueError,):
+                pass
+
+        try:
+            value = self._from_arg(arg)
+        except AssertionError as e:
+            raise ValueError(f'Could not convert {arg=} to t={self.t}.') from e
+
+        return value

stranded-0.0.1.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: stranded
+Version: 0.0.1
+Summary: Composable decorators for caching, retrying, throttling, logging, and CLIs, for both sync and asyncio code
+Author-email: Cameron Evans <c.d.evans87@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cevans87/Stranded
+Project-URL: Issues, https://github.com/cevans87/Stranded/issues
+Project-URL: Repository, https://github.com/cevans87/Stranded.git
+Keywords: asyncio,back pressure,cache,memoize,rate limit,retry,throttle
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Logging
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mypy; extra == "test"
+Dynamic: license-file
+
+# Stranded
+
+Composable decorators for caching, retrying, throttling, logging, and building
+command-line interfaces. Every decorator works on both plain and `async def`
+functions, picking the threading or asyncio implementation from the function it
+wraps.
+
+Stranded is alpha software. The API changes between releases.
+
+## Install
+
+```bash
+pip install stranded
+```
+
+Python 3.13 or newer is required. There are no runtime dependencies.
+
+## Usage
+
+Each decorator is a frozen dataclass. Configure it with keyword arguments and
+apply it to a function. The same decorator works for sync and async code.
+
+```python
+import asyncio
+
+from stranded.functools import LruCache, Retry, Throttle
+
+
+@LruCache(size=128)
+def fib(n: int) -> int:
+    return n if n < 2 else fib(n - 1) + fib(n - 2)
+
+
+@Retry(n=3)
+@Throttle(max_running=4)
+async def fetch(url: str) -> str:
+    await asyncio.sleep(0)
+    return url
+
+
+print(fib(40))
+print(asyncio.run(fetch('https://example.com')))
+```
+
+### functools
+
+- `LruCache(size=...)` memoizes by argument, sharing one in-flight result
+  between concurrent callers.
+- `Herd()` collapses concurrent calls with the same arguments into one call,
+  without memoizing the result.
+- `Retry(n=...)` re-invokes the function when it raises, up to `n` times.
+- `Throttle(max_running=..., max_waiting=...)` bounds concurrency. The running
+  cap grows additively while calls succeed and halves when a call raises.
+
+Each also has an instance with default settings, spelled in lowercase:
+`lru_cache`, `herd`, `retry`, `throttle`.
+
+### logging
+
+`Logger` logs a function's call, return value, and exceptions at configurable
+levels.
+
+```python
+import logging
+
+from stranded.logging import Logger
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+@Logger(call_level='DEBUG', return_level='INFO', exception_level='ERROR')
+def add(a: int, b: int) -> int:
+    return a + b
+
+
+add(1, 2)
+```
+
+### sqlite3
+
+`Db` memoizes a function's results to a SQLite database on disk, so results
+survive across processes.
+
+```python
+import pathlib
+import tempfile
+
+from stranded.sqlite3 import Db
+
+with tempfile.TemporaryDirectory() as tmp:
+
+    @Db(path=pathlib.Path(tmp) / 'db')
+    def expensive(key: str) -> str:
+        print('computing', key)
+        return key.upper()
+
+    print(expensive('a'))
+    print(expensive('a'))
+```
+
+### argparse
+
+`ArgumentParser` builds a command-line parser from a function's signature and
+type hints. Flags come before positionals, a boolean flag is spelled with one
+dash, and a valued flag with two. Parsers compose with `|`, so flags shared
+across subcommands can be written once.
+
+```python
+from stranded.argparse import ArgumentParser
+
+
+@ArgumentParser()
+def verbose_flag(*, verbose: bool = False) -> None:
+    if verbose:
+        print('verbose on')
+
+
+@ArgumentParser()
+def main(name: str, /, *, count: int = 1) -> None:
+    for _ in range(count):
+        print(f'hello, {name}')
+
+
+(verbose_flag | main)('-verbose', '--count', '2', 'world')
+```
+
+### Explicit sync and async variants
+
+The top-level decorators dispatch on whether the wrapped function is a
+coroutine function. To pin one, import from the `asyncio` or `threading`
+subpackage instead, for example `stranded.functools.asyncio.LruCache`.
+
+## Development
+
+```bash
+pip install -e '.[test]'
+pytest
+```
+
+## License
+
+MIT. See `LICENSE`.

stranded-0.0.1.dist-info/RECORD

@@ -0,0 +1,71 @@
+stranded/__init__.py,sha256=nDENyQrFI9vlhcsGdgUvjP_N0URC0FofrsoEIockk-4,1750
+stranded/composer_.py,sha256=SMvYUXVa8YZRpCATwoQgPdDn3OX543J48M8GSiAtNNE,1034
+stranded/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stranded/abc/__init__.py,sha256=vh0koY0sNE8PhT0RElYmUHazmUsnyXv9Azt_KPOMQg0,552
+stranded/abc/composer_.py,sha256=GnDulyWuaswn5QrDAXa28vGvJLG8jAo9YrFyzw9H7b4,6778
+stranded/argparse/__init__.py,sha256=QnQa0ni-61tnGJxx6IZYC_f4XnF92pczxwZDwwJlgf4,801
+stranded/argparse/argument_parser_.py,sha256=9Jla9KEGJ-HE4shtJC4ms1UkxEQ3fkdU0Dy-wxPZL6w,343
+stranded/argparse/abc/__init__.py,sha256=JQQG-NbmY2KMikUqTeAfrNrqYO_U44X4L5-NoUGXoUQ,617
+stranded/argparse/abc/argument_parser_.py,sha256=iHbB_Fmohpk7dnVhvhr7aWm_gZ5AsoFT4Wce7bt7vBQ,23877
+stranded/argparse/asyncio/__init__.py,sha256=QnQa0ni-61tnGJxx6IZYC_f4XnF92pczxwZDwwJlgf4,801
+stranded/argparse/asyncio/argument_parser_.py,sha256=fUYFgW-iT2ZVXvibykCIrCw2WtsGTVW8cuag8goIokM,1713
+stranded/argparse/threading/__init__.py,sha256=QnQa0ni-61tnGJxx6IZYC_f4XnF92pczxwZDwwJlgf4,801
+stranded/argparse/threading/argument_parser_.py,sha256=HEGoP98nctuWmaTIPkH2TF1Xzmy-4FzVJlgBoAXjLr0,1753
+stranded/asyncio/__init__.py,sha256=vh0koY0sNE8PhT0RElYmUHazmUsnyXv9Azt_KPOMQg0,552
+stranded/asyncio/composer_.py,sha256=ZnI7VqXPbwRniF-Xce_LcXziHXNz_DbqBWTl5HOSH_8,3098
+stranded/builtins/__init__.py,sha256=jwZwdifwUyrs14Z7G1qlwrMC3joyFNB4ewcEt5AaJqw,562
+stranded/builtins/exception_.py,sha256=XKS5MOlv4hWJehajJ3Q0-e8428zUQ5CrWi0C8Iy4hs4,103
+stranded/execution/__init__.py,sha256=LVxOCwEmRcfe_t2aGfd_v1X0kWzSOSh2_UeNWv_YJCM,911
+stranded/execution/scheduler_.py,sha256=b8SG3X2_3Rd4KQOREQ4exj8Zx4_UW9jjQg3-np2wcuo,1959
+stranded/execution/abc/__init__.py,sha256=65au4in0EJNuc36IMPueDim_NxPG7rWRigi_BuCMI20,562
+stranded/execution/abc/scheduler_.py,sha256=dgrU84UANr4Aio8GA3iL3Wab2XEATsBevnCAMHvH0d4,1839
+stranded/execution/asyncio/__init__.py,sha256=65au4in0EJNuc36IMPueDim_NxPG7rWRigi_BuCMI20,562
+stranded/execution/asyncio/scheduler_.py,sha256=Gtz_JyYpJEbJG6Mtr3Xq4ylaOvTbZnJCN-BhOj9hfG0,3216
+stranded/execution/threading/__init__.py,sha256=65au4in0EJNuc36IMPueDim_NxPG7rWRigi_BuCMI20,562
+stranded/execution/threading/scheduler_.py,sha256=wqRRBO_Smvw-zD2NNQh0jNK80TelG2_zJ4MMDPXz20A,3990
+stranded/functools/__init__.py,sha256=HpfZqC3K4hpx1YCUz5UFy0PXFGumVO8yPlczteYeoMk,1827
+stranded/functools/herd_.py,sha256=hkkHjdGceXtWjn4QnG8WKqNSFKWwWHKomSP9I_ukHg8,447
+stranded/functools/lru_cache_.py,sha256=IC8wIGQFMGA3JVhEMth3TBPj2CXDfFN7N76yVSFV-5Y,478
+stranded/functools/retry_.py,sha256=09EpfbmDrPfdjBhQmQWvaV7WG8OpOKhXBpXJq6fCagA,255
+stranded/functools/throttle_.py,sha256=Up6aW2z5bxW0nsv3KCkMyuxMxTjVtD4gS0zDxC8_Fs0,276
+stranded/functools/abc/__init__.py,sha256=2hDykfn7v2RWAz2RtYqm2vfgRTPjM3HAXFkTDzyk0eI,1295
+stranded/functools/abc/herd_.py,sha256=9mL4R7YAMint22v9CG1gACj6kYXsFR93pXxUy5cTo_o,3347
+stranded/functools/abc/lru_cache_.py,sha256=zcDeQ1caXENsVokUpTp073q_Owzr5J2ZZzFpq3yLXPs,7208
+stranded/functools/abc/retry_.py,sha256=RC_Eqxtu2ZK7raKVqOU30K7_-2ZXCyvrZq-2LylN5HY,1836
+stranded/functools/abc/throttle_.py,sha256=Enfk1G7HLg-Cc937RvuVmmIOezlgvK6Smi2KF6sY1BU,3500
+stranded/functools/asyncio/__init__.py,sha256=HpfZqC3K4hpx1YCUz5UFy0PXFGumVO8yPlczteYeoMk,1827
+stranded/functools/asyncio/herd_.py,sha256=9VyhixZZQdZsHkes0Fuk9Eyky9udxB0yguemGrSmOZQ,2929
+stranded/functools/asyncio/lru_cache_.py,sha256=1GbA2aRFuxLGF4etLzo-xeO1-82MOVq4rBDKzjmexWk,3153
+stranded/functools/asyncio/retry_.py,sha256=Vh3bJuptFneshSW_01nmVRyahw2zOl44SVANCBfPxe8,1329
+stranded/functools/asyncio/throttle_.py,sha256=4N7GhKAeOfXtmCbrG8U5ei7z2-X0kdUIk0D34r3FNbg,2801
+stranded/functools/threading/__init__.py,sha256=HpfZqC3K4hpx1YCUz5UFy0PXFGumVO8yPlczteYeoMk,1827
+stranded/functools/threading/herd_.py,sha256=BGXLC5o0siIugmnt6HxMMG9e8tk8bAYsJJLgNpxJAKM,2876
+stranded/functools/threading/lru_cache_.py,sha256=aWyPfpc8af8ZJ5ThCXfl7wJNktLkx5gROtKqGuEv2hc,3077
+stranded/functools/threading/retry_.py,sha256=PvtESoU_7HEURAt3_jvojw20VAJvJdwyh5ch68eRv3Q,1286
+stranded/functools/threading/throttle_.py,sha256=37hkiE8muUpie0KTxqepLVE-5XYYAjXN2_0ISjeIrjc,2720
+stranded/logging/__init__.py,sha256=47w05V7_RyAFffqHCW_ZNNdz-8ptYLVSf_vE5sLjQ10,661
+stranded/logging/logger_.py,sha256=ntKQep41NKdjFpkkJdAAf4aktLRVU7kvuhafyw2bCPE,262
+stranded/logging/abc/__init__.py,sha256=LfTSmVUnw26en-EaC5A6myMZohOjze04Zf2OJnHl9oE,531
+stranded/logging/abc/logger_.py,sha256=pVcBugYhCdaJKzbM1UPJdZ-S9BvGF6phrzQLYRrpKl8,3380
+stranded/logging/asyncio/__init__.py,sha256=LfTSmVUnw26en-EaC5A6myMZohOjze04Zf2OJnHl9oE,531
+stranded/logging/asyncio/logger_.py,sha256=QmzVx_hSC4NGyL-BvSTLZ7fwJ5Eurig-RJT3iVS-tj0,1330
+stranded/logging/threading/__init__.py,sha256=LfTSmVUnw26en-EaC5A6myMZohOjze04Zf2OJnHl9oE,531
+stranded/logging/threading/logger_.py,sha256=lAhn6cSpaL1mE0_VPc2Nv4k-3xP8K-EbqJRleZ2hVLo,1288
+stranded/sqlite3/__init__.py,sha256=PTn-sHCJmOUNRtm2iBNcXwziXvttU-8rSKrDskY0lz8,597
+stranded/sqlite3/db_.py,sha256=Fas_ZY_HaJGiYh5xM3Q4K3rlLPztHrqaML9GwQ00Mew,256
+stranded/sqlite3/abc/__init__.py,sha256=AA8a5HfjRE90TX4Co_VNmDgsp5C67qIHhk9-VPXr2DY,491
+stranded/sqlite3/abc/db_.py,sha256=MdNo0OYJ5kSJyfg43GBfi_u_f-Z3m_EfMdp2D1EFreQ,5761
+stranded/sqlite3/asyncio/__init__.py,sha256=PTn-sHCJmOUNRtm2iBNcXwziXvttU-8rSKrDskY0lz8,597
+stranded/sqlite3/asyncio/db_.py,sha256=XZcgMNvvFGydRjfeW_j0alMrwjfsxA34xkSiFKWijSs,1296
+stranded/sqlite3/threading/__init__.py,sha256=PTn-sHCJmOUNRtm2iBNcXwziXvttU-8rSKrDskY0lz8,597
+stranded/sqlite3/threading/db_.py,sha256=UECsxmG4wWvibou8GXFn5GFhsIUsYR6OIWXI8KKD1qU,1254
+stranded/threading/__init__.py,sha256=vh0koY0sNE8PhT0RElYmUHazmUsnyXv9Azt_KPOMQg0,552
+stranded/threading/composer_.py,sha256=TywIejKpsjgbhDCcDA20icH7RClEkfhvP2-hG36tFg4,3010
+stranded/types/__init__.py,sha256=2FxjaZZoOjxFxNolPcKqoyU14id-vb2Dwcpt8PNtQ08,535
+stranded/types/constraint.py,sha256=v9jUZ2J1JAptNTLsdvJQ23BlfaMiAE4ijw8KHYf3A0w,146
+stranded/types/convert.py,sha256=AO813y8Puvb8OTdnF4ORuoayhUOkOyA6J86vIABebCg,6999
+stranded-0.0.1.dist-info/licenses/LICENSE,sha256=qIvbV-1GDfl0aBLJVxbjAKW8ldGZh9pVpURzg6B6kBQ,1070
+stranded-0.0.1.dist-info/METADATA,sha256=MT22PQlIC-HXCPmuOVoPwXFlMLSe-5IQ9_Ojbr0cRGw,4621
+stranded-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+stranded-0.0.1.dist-info/top_level.txt,sha256=E6RGZlacwMCtIgz14kMDlMZhYpIuX3GGQzCq9n-9Z3A,9
+stranded-0.0.1.dist-info/RECORD,,

stranded-0.0.1.dist-info/WHEEL

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

stranded-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Cameron Evans
+
+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.

stranded-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+stranded