patos 0.0.1__py3-none-any.whl

patos/__init__.py

@@ -0,0 +1,25 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .dispatch import value_dispatch
+from .flags import flags
+from .flyweight import Flyweight, FlyweightMeta
+from .registry import Registry
+from .singleton import Singleton
+from .strategy import Strategy
+from .strflag import StrFlag
+
+try:
+    __version__ = version("patos")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = [
+    "Flyweight",
+    "FlyweightMeta",
+    "Registry",
+    "Singleton",
+    "StrFlag",
+    "Strategy",
+    "flags",
+    "value_dispatch",
+]

patos/_catalog.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class Pato:
+    """A single pattern in the flock, copyable as one self-contained module.
+
+    module: file name inside `patos/` (without directory), e.g. `registry.py`.
+    summary: one-line description shown by `patos list`.
+    exports: public symbols the module defines and the package re-exports.
+    extras: optional dependency groups this pato needs (empty for zero-dep patos).
+    doc: documentation page path under `docs/`, e.g. `patos/registry.md`.
+    """
+
+    module: str
+    summary: str
+    exports: tuple[str, ...]
+    extras: tuple[str, ...] = ()
+    doc: str = ""
+
+
+PATOS: dict[str, Pato] = {
+    "registry": Pato(
+        module="registry.py",
+        summary="Self-registering class hierarchies: subclasses enroll via __init_subclass__.",
+        exports=("Registry",),
+        doc="patos/registry.md",
+    ),
+    "singleton": Pato(
+        module="singleton.py",
+        summary="One instance per class, __init__ runs once.",
+        exports=("Singleton",),
+        doc="patos/singleton.md",
+    ),
+    "flyweight": Pato(
+        module="flyweight.py",
+        summary="Intern instances by constructor args (build-once, immutable).",
+        exports=("Flyweight", "FlyweightMeta"),
+        doc="patos/flyweight.md",
+    ),
+    "strategy": Pato(
+        module="strategy.py",
+        summary="A named family of interchangeable implementations, selected at runtime.",
+        exports=("Strategy",),
+        doc="patos/strategy.md",
+    ),
+    "dispatch": Pato(
+        module="dispatch.py",
+        summary="Dispatch on a value the way singledispatch dispatches on a type.",
+        exports=("value_dispatch",),
+        doc="patos/dispatch.md",
+    ),
+    "flags": Pato(
+        module="flags.py",
+        summary="Turn keyword options into a CLI argv tuple.",
+        exports=("flags",),
+        doc="patos/flags.md",
+    ),
+    "strflag": Pato(
+        module="strflag.py",
+        summary="An enum Flag whose members carry a literal string, OR-combinable and iterable.",
+        exports=("StrFlag",),
+        doc="patos/strflag.md",
+    ),
+}

patos/dispatch.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import functools
+from collections.abc import Callable, Hashable
+from types import MappingProxyType
+from typing import Any
+
+
+class value_dispatch:
+    """Turn a function into a value-dispatched generic.
+
+    Like `functools.singledispatch`, but the dispatch key is the *value* of a
+    keyword argument (default `"kind"`) rather than the *type* of the first
+    positional argument. Both decorator forms work:
+
+        @value_dispatch
+        def render(node, **kw): ...        # bare: kind is "kind"
+
+        @value_dispatch(kind="how")
+        def render(node, **kw): ...        # kind is "how"
+
+    Implementations register under a key with `@render.register`. Each is also
+    exposed as an attribute (`render.html`) so callers that already know the
+    kind can skip the registry lookup. Calling with no kind (or `kind=None`)
+    falls back to the originally decorated function.
+
+    fallback: the wrapped function; supplied implicitly by the decorator.
+    kind: name of the keyword argument carrying the dispatch value.
+    """
+
+    def __init__(
+        self,
+        fallback: Callable[..., Any] | None = None,
+        *,
+        kind: str = "kind",
+    ) -> None:
+        self.kind_arg = kind
+        self.registry_map: dict[Hashable, Callable[..., Any]] = {}
+        self.fallback: Callable[..., Any] | None = None
+        if fallback is not None:
+            self.bind_fallback(fallback)
+
+    def bind_fallback(self, fallback: Callable[..., Any]) -> None:
+        """Adopt `fallback` as the default impl and copy its metadata onto self."""
+        self.fallback = fallback
+        functools.update_wrapper(self, fallback)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Bind the fallback on the parametrised first call, otherwise dispatch.
+
+        With no fallback yet, this is the parametrised-decorator stage: the sole
+        argument is the function to wrap. Once bound, pop the kind keyword and
+        route to its registered impl, falling back when the kind is absent.
+        """
+        if self.fallback is None:
+            self.bind_fallback(args[0])
+            return self
+        value = kwargs.pop(self.kind_arg, None)
+        if value is None:
+            return self.fallback(*args, **kwargs)
+        try:
+            impl = self.registry_map[value]
+        except KeyError:
+            raise ValueError(
+                f"{self.fallback.__name__}: unknown {self.kind_arg}={value!r}; "
+                f"choose from {sorted(self.registry_map, key=repr)}",
+            ) from None
+        return impl(*args, **kwargs)
+
+    def register(
+        self,
+        arg: Hashable | Callable[..., Any] | None = None,
+        *,
+        name: Hashable | None = None,
+    ) -> Callable[..., Any] | Callable[[Callable[..., Any]], Callable[..., Any]]:
+        """Register an implementation under a kind value.
+
+        Three forms:
+        - `@register` bare: key is the function's `__name__`.
+        - `@register("foo")` or `@register(name="foo")`: explicit key.
+        - `register(existing, name="alias")`: register an existing function.
+
+        When the key is a valid identifier the impl is also set as a dispatcher
+        attribute, enabling direct `dispatcher.foo(...)` calls.
+
+        arg: explicit key, or the function itself in the bare/direct forms.
+        name: explicit key, taking precedence over `arg` and the `__name__`.
+        """
+        if callable(arg):
+            return self.bind(arg, arg.__name__ if name is None else name)
+        key = arg if name is None else name
+
+        def decorate(impl: Callable[..., Any]) -> Callable[..., Any]:
+            return self.bind(impl, impl.__name__ if key is None else key)
+
+        return decorate
+
+    def bind(self, impl: Callable[..., Any], key: Hashable) -> Callable[..., Any]:
+        """Store `impl` under `key`, also exposing it as an attribute when key is an identifier."""
+        self.registry_map[key] = impl
+        if isinstance(key, str) and key.isidentifier():
+            setattr(self, key, impl)
+        return impl
+
+    @property
+    def registry(self) -> MappingProxyType[Hashable, Callable[..., Any]]:
+        """Read-only view of the kind to impl mapping."""
+        return MappingProxyType(self.registry_map)
+
+    def kinds(self) -> list[Hashable]:
+        """All registered kinds, sorted by their `repr` so mixed-type keys stay orderable."""
+        return sorted(self.registry_map, key=repr)
+
+    def __contains__(self, key: Hashable) -> bool:
+        return key in self.registry_map
+
+    def __repr__(self) -> str:
+        name = self.fallback.__name__ if self.fallback else "(unbound)"
+        return f"<value_dispatch {name!r} kinds={self.kinds()}>"

patos/flags.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TypeAlias
+
+FlagValue: TypeAlias = bool | int | str | Sequence[str] | None
+
+
+def flags(
+    *,
+    joined: bool = False,
+    separator: str | None = None,
+    **options: FlagValue,
+) -> tuple[str, ...]:
+    """Turn keyword options into a CLI argv tuple, dropping the empty ones.
+
+    Keys become long flags with underscores hyphenated (`mem_gb` -> `--mem-gb`).
+    Rendering by value type:
+
+    - `None`, `False`, `""`: dropped entirely.
+    - `True`: a bare `--flag`.
+    - `int` / `str`: `--flag value` (or `--flag=value` when `joined`).
+    - sequence: by default one `--flag value` pair per item; with `separator`
+      a single `--flag a,b,c` joined on `separator`. Empty sequences drop.
+
+    joined: emit `--flag=value` single tokens instead of `--flag` then `value`.
+    separator: join sequence values into one flag instead of repeating it.
+    options: the flag name to value mapping.
+    """
+    argv: list[str] = []
+    for key, value in options.items():
+        flag = f"--{key.replace('_', '-')}"
+        if value is None or value is False or value == "":
+            continue
+        if value is True:
+            argv.append(flag)
+        elif isinstance(value, str | int):
+            argv.extend(emit(flag, str(value), joined=joined))
+        elif separator is not None:
+            argv.extend(emit(flag, separator.join(value), joined=joined))
+        else:
+            for item in value:
+                argv.extend(emit(flag, item, joined=joined))
+    return tuple(argv)
+
+
+def emit(flag: str, value: str, *, joined: bool) -> tuple[str, ...]:
+    """Render one flag/value pair as `("--flag=value",)` or `("--flag", "value")`."""
+    return (f"{flag}={value}",) if joined else (flag, value)

patos/flyweight.py

@@ -0,0 +1,31 @@
+from abc import ABCMeta
+from typing import Any
+
+
+class FlyweightMeta(ABCMeta):
+    """Metaclass that interns instances by their construction arguments.
+
+    The first construction with a given `(args, kwargs)` builds and caches the instance; every
+    later construction with equal arguments returns that same object without re-running
+    `__init__` -- the metaclass owns `__call__`, so no re-entrancy guard is needed (unlike
+    caching `__new__`, which still re-runs `__init__`). Each class keeps its own cache and
+    arguments must be hashable. Subclasses `ABCMeta` so a flyweight can also be an abstract
+    base or carry abstract methods.
+    """
+
+    def __call__(cls, *args: Any, **kwargs: Any) -> Any:
+        cache: dict[tuple[Any, ...], Any] = cls.__dict__.get("flyweights", {})
+        if "flyweights" not in cls.__dict__:
+            cls.flyweights = cache
+        key = (args, frozenset(kwargs.items()))
+        if key not in cache:
+            cache[key] = super().__call__(*args, **kwargs)
+        return cache[key]
+
+
+class Flyweight(metaclass=FlyweightMeta):
+    """Base for interned, build-once value objects: equal constructor arguments share one
+    instance (the flyweight / multiton pattern). Fits objects that are expensive to build and
+    immutable once built -- a lattice codebook, a trellis -- so a sweep or repeated
+    construction pays the build cost once. `Singleton` is the degenerate no-argument case.
+    """

patos/registry.py

@@ -0,0 +1,65 @@
+from typing import Any, ClassVar, Self, cast
+
+
+class Registry:
+    """Mixin for self-registering class hierarchies with try-each dispatch.
+
+    Each direct child of `Registry` becomes a registry root that owns the list of its
+    own concrete subclasses. `registry()` lists implementations; `dispatch` tries each
+    registered implementation's `from_dispatch` until one succeeds.
+    """
+
+    registry_entries: ClassVar[list[type["Registry"]]]
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Register `cls` as a root (if a direct child) and into its nearest root."""
+        super().__init_subclass__(**kwargs)
+
+        if Registry in cls.__bases__:
+            cls.registry_entries = []
+
+        for base in cls.__mro__:
+            if "registry_entries" in base.__dict__:
+                base.registry_entries.append(cls)
+                return
+
+    @classmethod
+    def registry(cls) -> list[type["Registry"]]:
+        """Return the implementation list owned by this class's nearest registry root."""
+        for base in cls.__mro__:
+            if "registry_entries" in base.__dict__:
+                return base.registry_entries
+        raise RuntimeError(f"No registry found for {cls.__name__}.")
+
+    @classmethod
+    def is_registry_root(cls) -> bool:
+        """Return whether this class owns a registry."""
+        return "registry_entries" in cls.__dict__
+
+    @classmethod
+    def dispatch(cls, *args: Any, **kwargs: Any) -> Self:
+        """Try each registered implementation's `from_dispatch`, returning the first success.
+
+        On a registry root, every other registered implementation is tried in order and the
+        last raised error is re-raised if all fail; off a root, `cls` dispatches directly.
+        """
+        if not cls.is_registry_root():
+            return cls.from_dispatch(*args, **kwargs)
+
+        last_error: Exception | None = None
+        for subclass in cls.registry():
+            if subclass is cls:
+                continue
+            try:
+                return cast(Self, subclass.from_dispatch(*args, **kwargs))
+            except Exception as error:
+                last_error = error
+
+        if last_error is not None:
+            raise last_error
+        raise RuntimeError(f"No implementation found in {cls.__name__} registry.")
+
+    @classmethod
+    def from_dispatch(cls, *args: Any, **kwargs: Any) -> Self:
+        """Build an instance from dispatch arguments; subclasses override this."""
+        raise NotImplementedError(f"{cls.__name__} does not implement from_dispatch.")

patos/singleton.py

@@ -0,0 +1,25 @@
+from typing import Any, ClassVar
+
+
+class SingletonMeta(type):
+    """Metaclass that yields one instance per class, building it at most once.
+
+    Owning `__call__` means the cached instance is returned without re-running `__init__`,
+    avoiding the wart of caching `__new__` (which re-initialises on every call). Each class
+    keeps its own instance, so subclasses are independent singletons.
+    """
+
+    instances: ClassVar[dict[type, Any]] = {}
+
+    def __call__(cls, *args: Any, **kwargs: Any) -> Any:
+        if cls not in SingletonMeta.instances:
+            SingletonMeta.instances[cls] = super().__call__(*args, **kwargs)
+        return SingletonMeta.instances[cls]
+
+
+class Singleton(metaclass=SingletonMeta):
+    """Base for single-instance classes: every construction returns the same object.
+
+    `__init__` runs only on the first construction, so later calls never re-initialise the
+    shared instance. The no-argument degenerate case of the flyweight pattern.
+    """

patos/strategy.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from typing import Generic, Protocol, TypeVar, runtime_checkable
+
+T = TypeVar("T")
+
+
+@runtime_checkable
+class Available(Protocol):
+    """An implementation that can report whether it applies on the current host.
+
+    Implementations may expose `available()` for first-available selection. Those
+    that do not are treated as always available, so plain value objects need no
+    boilerplate to participate in named selection.
+    """
+
+    def available(self) -> bool:
+        """Whether this implementation should be chosen in `first_available` mode."""
+
+
+class StrategyError(KeyError):
+    """Raised when a name is missing with no default, or no impl is available."""
+
+
+class Strategy(Generic[T]):
+    """A family of interchangeable named implementations with runtime selection.
+
+    `Strategy` replaces the bespoke `{"a": A(), "b": B()}.get(kind, default)` and
+    "pick the first thing that works" dispatch tables scattered across services.
+    Implementations register by name, eagerly (a value) or lazily (a zero-arg
+    factory called on first use and cached). Two selection modes:
+
+    - `select(name, default=...)`: keyed lookup, like `dict.get` but raising a
+      clear `StrategyError` instead of returning `None` when nothing matches.
+    - `first_available()`: walk registrations in insertion order and return the
+      first whose `available()` predicate is true (impls without one always are).
+
+    It is generic over the implementation or Protocol type, so `Strategy[Scheduler]`
+    keeps `select`/`first_available` returning `Scheduler`.
+
+    name: human-readable label used in error messages.
+    """
+
+    def __init__(self, name: str = "strategy") -> None:
+        self.name = name
+        self.factories: dict[str, Callable[[], T]] = {}
+        self.cache: dict[str, T] = {}
+
+    def register(self, name: str, impl: T) -> None:
+        """Register an already-built implementation value under `name`.
+
+        impl: the implementation; stored as-is and returned by `select`/`first_available`.
+        """
+        self.cache[name] = impl
+        self.factories[name] = lambda: impl
+
+    def factory(self, name: str, build: Callable[[], T]) -> None:
+        """Register a zero-arg factory under `name`, built lazily on first resolution.
+
+        name: the implementation key.
+        build: produces the implementation the first time it is selected; cached after.
+        """
+        self.factories[name] = build
+
+    def add(self, name: str) -> Callable[[Callable[[], T]], Callable[[], T]]:
+        """Decorator form of `factory`, registering the decorated zero-arg builder under `name`."""
+
+        def decorate(build: Callable[[], T]) -> Callable[[], T]:
+            self.factory(name, build)
+            return build
+
+        return decorate
+
+    def resolve(self, name: str) -> T:
+        """Build (once) and return the implementation registered under `name`."""
+        try:
+            return self.cache[name]
+        except KeyError:
+            self.cache[name] = self.factories[name]()
+            return self.cache[name]
+
+    def select(self, name: str, default: str | None = None) -> T:
+        """Return the impl for `name`, or for `default`, raising if neither is registered.
+
+        name: the requested implementation key.
+        default: fallback key used when `name` is unknown; `None` means no fallback.
+        """
+        if name in self.factories:
+            return self.resolve(name)
+        if default is not None and default in self.factories:
+            return self.resolve(default)
+        raise StrategyError(
+            f"{self.name}: no implementation for {name!r}; choose from {sorted(self.factories)}"
+        )
+
+    def first_available(self) -> T:
+        """Return the first registered impl whose `available()` is true, in insertion order.
+
+        Implementations that do not expose `available()` count as always available,
+        so a plain default placed last is the catch-all.
+        """
+        for name in self.factories:
+            impl = self.resolve(name)
+            if not isinstance(impl, Available) or impl.available():
+                return impl
+        raise StrategyError(
+            f"{self.name}: no available implementation among {sorted(self.factories)}"
+        )
+
+    @property
+    def names(self) -> tuple[str, ...]:
+        """Registered names in insertion order."""
+        return tuple(self.factories)
+
+    def __contains__(self, name: str) -> bool:
+        return name in self.factories
+
+    def __len__(self) -> int:
+        return len(self.factories)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.factories)
+
+    def __repr__(self) -> str:
+        return f"<Strategy {self.name!r} names={list(self.factories)}>"

patos/strflag.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from enum import Flag
+
+
+class StrFlag(Flag):
+    """A ``Flag`` whose members carry a literal string, kept OR-combinable and iterable.
+
+    Each member gets the next power-of-two value (so members compose with ``|`` and iterate)
+    while the declared string lives on ``.string``. Handy for building command-line option
+    sets where the enum is the vocabulary and ``.string`` is what you emit.
+
+    ```python
+    class Opt(StrFlag):
+        ALL = "-a"
+        BIG = "--big"
+
+    [m.string for m in (Opt.ALL | Opt.BIG)]  # ['-a', '--big']
+    ```
+    """
+
+    string: str
+
+    def __new__(cls, string: str) -> StrFlag:
+        member = object.__new__(cls)
+        member._value_ = 1 << len(cls.__members__)
+        member.string = string
+        return member

patos-0.0.1.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: patos
+Version: 0.0.1
+Summary: Typed Python design and dispatch patterns, pip one in or copy one in and own the file
+Project-URL: Homepage, https://phvv.me/patos
+Project-URL: Repository, https://github.com/phvv-me/patos
+Project-URL: Issues, https://github.com/phvv-me/patos/issues
+Author-email: Pedro Valois <contact@phvv.me>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6; extra == 'dev'
+Requires-Dist: pyrefly>=1; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest-randomly>=3; extra == 'dev'
+Requires-Dist: pytest>=9; extra == 'dev'
+Requires-Dist: ruff>=0.15; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-llmstxt>=0.2; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs-static-i18n>=1.2; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# patos
+
+[![CI](https://github.com/phvv-me/patos/actions/workflows/ci.yml/badge.svg)](https://github.com/phvv-me/patos/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/badge/docs-phvv.me%2Fpatos-2563EB)](https://phvv.me/patos)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+
+[🇧🇷](https://phvv.me/patos/pt-BR/) [🇲🇽](https://phvv.me/patos/es/) [🇯🇵](https://phvv.me/patos/ja/) [🇨🇳](https://phvv.me/patos/zh/)
+
+A flock of typed Python patterns. Pip one in, or copy one in and own the file.
+
+Each pattern is a single self-contained `pato`, a duck you adopt. Every duck is fully typed,
+standard library only, and small enough to read in one sitting.
+
+## Two ways to use a pato
+
+Install the whole flock and import the patterns you want.
+
+```sh
+pip install patos
+```
+
+```python
+from patos import Registry
+```
+
+Or copy a single duck. Open its docs page, copy the source from the Source section, and paste it
+into your own project. No dependency, no version pin, no tool, just one module you own.
+
+## Example
+
+```python
+from patos import Singleton
+
+
+class Settings(Singleton):
+    def __init__(self) -> None:
+        self.debug = False
+
+
+a = Settings()
+a.debug = True
+b = Settings()      # same object, __init__ did not run again
+
+assert a is b and b.debug
+```
+
+## The flock
+
+| pato | does |
+|---|---|
+| `registry` | self-registering class hierarchies via `__init_subclass__` |
+| `singleton` | one instance per class, `__init__` runs once |
+| `flyweight` | intern instances by constructor args, build-once and immutable |
+| `strategy` | a named family of interchangeable implementations |
+| `dispatch` | dispatch on a value the way `singledispatch` dispatches on a type |
+| `flags` | turn keyword options into a CLI argv tuple |
+| `strflag` | an enum `Flag` whose members carry a literal string, OR-combinable and iterable |
+
+## Documentation
+
+Full documentation lives at [https://phvv.me/patos](https://phvv.me/patos).
+
+## Development
+
+This project's dev environment is managed by [chefe](https://phvv.me/chefe).
+
+- Install: `chefe install`
+- Lint: `chefe run lint`
+- Typecheck: `chefe run typecheck`
+- Test: `chefe run test`
+- Docs: `chefe run docs`
+- Build: `uv build`

patos-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+patos/__init__.py,sha256=Vp2leXMBS-fF4LRPoBaRHXLmzEohkUvvXesF1eJcdtw,544
+patos/_catalog.py,sha256=Xf5YmF_1iQ_0EEM2KRbK6j7_EOC86bK1BMmS7UkuE7o,2134
+patos/dispatch.py,sha256=Q1pGAfKqqeXEYCTOePXGNkFf4FjwdWAjoenUg47VnfE,4720
+patos/flags.py,sha256=tvdFwikkDYwK9bubTtGO6hw5GtR6n3BvQZfXs9TmRqE,1800
+patos/flyweight.py,sha256=KNqFQ9CqHMKkvVnTm7PbMEmx0-QiQNqe1W4xRxhGcL0,1444
+patos/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+patos/registry.py,sha256=93vZbn3drmSs_bo6yswUZZOJTwSnbd5q3sVXFWZ49Ps,2553
+patos/singleton.py,sha256=wARFaicksCnRQRTeIAec4En2Dfnv4Q7pgy6M-2ey5sw,984
+patos/strategy.py,sha256=1uL5Begz0T2exf-hFpxZHOraWy-A5JxM4UtWfpAs2Ik,4804
+patos/strflag.py,sha256=xsQC4AxB4fRl5Ow15qC3XQvxjWhjC0tXwxq9ZcNcAm0,796
+patos-0.0.1.dist-info/METADATA,sha256=TyL9-l-4cUtJ81XKtESKAS2B-YCx7TZ8ne3Vid32IKA,3605
+patos-0.0.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+patos-0.0.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+patos-0.0.1.dist-info/RECORD,,

patos-0.0.1.dist-info/WHEEL

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

patos-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.