policy-pattern 0.1.0__py3-none-any.whl

policy_pattern/models/subject_set.py

@@ -0,0 +1,56 @@
+"""
+Value Object representing a set of subjects in the authorization graph.
+"""
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+from .identifier import Identifier
+from .object_reference import ObjectReference
+
+
+@dataclass(frozen=True, slots=True)
+class SubjectSet:
+    """
+    Value Object representing a set of subjects.
+
+    A subject set is a reference to *a relation on an object* — not a
+    single entity like `DirectSubject`/`ObjectReference`, but the set of
+    whoever holds that relation. `group:eng#member` refers to every
+    current member of `group:eng`, resolved at evaluation time, not a
+    fixed list stored here.
+
+    This is the other half of `Subject` (`Subject = DirectSubject |
+    SubjectSet`): `DirectSubject` names one entity;
+    `SubjectSet` names a computation over the graph ("whoever satisfies
+    this relation on this object right now"). It is exactly how nested
+    groups work in Zanzibar — `group:eng#member@group:backend#member`
+    makes every member of `group:backend` a member of `group:eng`,
+    without ever copying a membership list.
+
+    `relation` delegates to `Identifier` like every other identifier-shaped
+    field in this model (`ObjectReference.type`/`.id`,
+    `Relation.allowed_subject_types` entries) — no separate bounds/charset
+    logic, no separate error class needed for it.
+
+    Example:
+        SubjectSet(object=ObjectReference(type="group", id="eng"), relation="member")
+
+    `object` is validated by `ObjectReference` itself; `relation` is
+    validated as an `Identifier` with `field="relation"`.
+
+    Raises:
+        InvalidIdentifierError: Propagated from `Identifier` if `relation` is invalid,
+            or from `ObjectReference` if `type`/`id` is invalid.
+    """
+
+    object: ObjectReference
+    relation: str
+
+    _RELATION_IDENTIFIER_FIELD: ClassVar[str] = "relation"
+
+    def __post_init__(self) -> None:
+        """
+        Validates the subject set after initialization by delegating to Identifier.
+        """
+        Identifier(value=self.relation, field=self._RELATION_IDENTIFIER_FIELD)

policy_pattern/models/tuple.py

@@ -0,0 +1,52 @@
+"""
+Value Object representing a stored relationship fact in the authorization graph.
+"""
+
+from dataclasses import dataclass
+
+from .identifier import Identifier
+from .object_reference import ObjectReference
+from .subject import Subject
+
+
+@dataclass(frozen=True, slots=True)
+class Tuple:
+    """
+    Value Object representing one stored fact: `object#relation@subject`.
+
+    e.g. `document:42#owner@user:john` is
+    `Tuple(subject=DirectSubject(object=ObjectReference(type="user", id="john")),
+    relation="owner", object=ObjectReference(type="document", id="42"))`.
+
+    `relation` only names a relation here — it is validated as an
+    `Identifier` (non-empty, bounded, printable), but *not* checked against
+    an actual `Relation`/`Permission` declaration. `Tuple` has no schema
+    context to check that against; confirming `relation` actually names a
+    storable `Relation` (never a `Permission`) is `compile()`'s job on the
+    `Model`, not this class's.
+
+    `subject`/`object` are validated by `Subject`'s variants
+    (`DirectSubject`/`SubjectSet`) and `ObjectReference` themselves —
+    `Tuple` only validates the one field it owns directly.
+
+    Example:
+        Tuple(
+            subject=DirectSubject(object=ObjectReference(type="user", id="john")),
+            relation="owner",
+            object=ObjectReference(type="document", id="42"),
+        )
+
+    Raises:
+        InvalidIdentifierError: If `relation` is invalid, or propagated from
+            `subject`/`object` construction.
+    """
+
+    subject: Subject
+    relation: str
+    object: ObjectReference
+
+    def __post_init__(self) -> None:
+        """
+        Validates the tuple after initialization by delegating relation to Identifier.
+        """
+        Identifier(value=self.relation, field="relation")

policy_pattern/models/tuple_to_userset.py

@@ -0,0 +1,51 @@
+"""
+Value Object representing a computed permission expression that traverses to a
+related object via a relation and evaluates a computed permission there.
+"""
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+from .identifier import Identifier
+from .operators import PermissionExpression
+
+
+@dataclass(frozen=True, slots=True)
+class TupleToUserset(PermissionExpression):
+    """
+    Traverses to a related object via `tupleset`, then evaluates `computed` there.
+
+    This is the one node that is not a set operation on *this* object — it
+    jumps to a *different* object first. `document:42#parent@folder:eng`
+    plus `TupleToUserset(tupleset="parent", computed="viewer")` reads as
+    "find the object(s) related to this one via `parent`, then check
+    `viewer` on *that* object instead." It is how folder hierarchies grant
+    access to every document underneath without copying a permission onto
+    each child individually, and how nested groups
+    (`group:eng#member@group:backend#member`) work without flattening
+    membership into a stored list.
+
+    `tupleset` must resolve to a `Relation`, never a `Permission` —
+    traversal needs an actual stored edge to follow (`document:42#parent`
+    has to exist as data); there is nothing to traverse if `parent` were
+    itself a computed rule. `computed` has no such restriction: it is
+    evaluated on the object found via `tupleset`, and can be either a
+    `Relation` or another `Permission` there, resolved the same way
+    `Reference` resolves its own `name`.
+
+    Example:
+        TupleToUserset(tupleset="parent", computed="viewer")
+    """
+
+    tupleset: str
+    computed: str
+
+    _FIELD_TUPLESET_VALUE: ClassVar[str] = "tupleset"
+    _FIELD_COMPUTED_VALUE: ClassVar[str] = "computed"
+
+    def __post_init__(self) -> None:
+        """
+        Validates `tupleset` and `computed` by delegating to `Identifier`.
+        """
+        Identifier(value=self.tupleset, field=self._FIELD_TUPLESET_VALUE)
+        Identifier(value=self.computed, field=self._FIELD_COMPUTED_VALUE)

policy_pattern/models/type.py

@@ -0,0 +1,71 @@
+"""
+Value Object representing a declaration mutable at authoring time, but immutable at evaluation time.
+"""
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import ClassVar
+
+from ..errors import InvalidIdentifierError
+from .identifier import Identifier
+from .operators import PermissionExpression
+from .relation import Relation
+
+
+@dataclass(frozen=True, slots=True)
+class Type:
+    """
+    Value Object representing a type declaration in the authorization graph.
+
+    A `Type` declares a kind of object, along with the relations and
+    permissions it supports.
+
+    Example:
+        Type(name="document", relations={}, permissions={})
+
+    Raises:
+        InvalidIdentifierError: Propagated from `Identifier` if `name`, a
+            relation name, or a permission name is invalid, or if `name`
+            contains '#' (reserved for userset notation).
+    """
+
+    name: str
+    relations: Mapping[str, Relation]
+    permissions: Mapping[str, PermissionExpression]
+
+    _TYPE_NAME_FIELD: ClassVar[str] = "type"
+    _RELATION_NAME_FIELD: ClassVar[str] = "relation"
+    _PERMISSION_NAME_FIELD: ClassVar[str] = "permission"
+
+    def __post_init__(self) -> None:
+        """
+        Validate `name` and every relation/permission name, then make the mappings read-only views.
+
+        `relations`/`permissions` keys are the actual schema identifiers —
+        `Reference`/`tupleset` names resolve against them — so they need the
+        same `Identifier` validation as `name` itself, not just the values.
+
+        `frozen=True` only blocks reassigning `relations`/`permissions`
+        themselves — a plain `dict` field would still be mutable in place
+        (`type_.relations["x"] = y`). Wrapping a copy in `MappingProxyType`
+        closes that gap: neither the returned view nor the caller's
+        original dict (once copied) can affect this instance afterward.
+        """
+        Identifier(value=self.name, field=self._TYPE_NAME_FIELD)
+        if "#" in self.name:
+            # Reserved for userset notation ("type#relation") inside
+            # Relation.allowed_subject_types — _schema_validation.py tells a
+            # plain type-name entry apart from a userset one by checking for
+            # "#" in the string. If a real Type name could contain "#" too,
+            # that check couldn't tell them apart.
+            raise InvalidIdentifierError(
+                message=f"type name {self.name!r} cannot contain '#' — reserved for userset notation",
+                related=f"field={self._TYPE_NAME_FIELD!r}",
+            )
+        for relation_name in self.relations:
+            Identifier(value=relation_name, field=self._RELATION_NAME_FIELD)
+        for permission_name in self.permissions:
+            Identifier(value=permission_name, field=self._PERMISSION_NAME_FIELD)
+        object.__setattr__(self, "relations", MappingProxyType(dict(self.relations)))
+        object.__setattr__(self, "permissions", MappingProxyType(dict(self.permissions)))

policy_pattern/ports/__init__.py

@@ -0,0 +1,7 @@
+from .tuple_store import ReadResult, TupleStore, View
+
+__all__ = [
+    "ReadResult",
+    "TupleStore",
+    "View",
+]

policy_pattern/ports/tuple_store.py

@@ -0,0 +1,118 @@
+"""
+Storage port: TupleStore/View abstractions and the bounded-read result type.
+"""
+
+from abc import ABC, abstractmethod
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+
+from ..models import Mutation, ObjectReference, Subject, Tuple
+
+
+@dataclass(frozen=True, slots=True)
+class ReadResult:
+    """
+    Result of a bounded `View.read_relation()` call.
+
+    `docs/semantics.md` requires that a truncated enumeration never be
+    representable as a complete one — `complete` carries that fact in the
+    type itself rather than a convention the caller has to already know
+    (e.g. a `limit + 1` sentinel). `tuples` is a `frozenset` — it carries no
+    order of its own. When more matching tuples exist than the caller's
+    `limit` allowed, `tuples` holds at most `limit` of them, deterministically
+    selected by the adapter's own canonical ranking (never arbitrary or
+    hash-order-dependent — see `MemoryTupleStore.read_relation`), and
+    `complete` is `False`; otherwise `tuples` holds all matches and
+    `complete` is `True`.
+
+    Example:
+        ReadResult(tuples=frozenset({...}), complete=True)
+    """
+
+    tuples: frozenset[Tuple]
+    complete: bool
+
+
+class TupleStore(ABC):
+    """
+    Storage port for authorization tuples — mutations plus consistent-snapshot reads.
+
+    Deliberately schema-agnostic: this class stores and compares
+    structurally well-formed `(subject, relation, object)` triples and
+    knows nothing about `Relation` vs `Permission`, rewrite rules, or
+    `compile()` — that separation is what keeps a `PostgresTupleStore`
+    substitutable for `MemoryTupleStore` without either one leaking into
+    the rewrite engine (`docs/architecture.md`).
+
+    `write_tuples()` is the only mutating method an adapter must implement.
+    `delete_tuples()` is concrete, not abstract — a pure deletion is already
+    representable as `Mutation(additions=frozenset(), deletions=tuples)`,
+    so every adapter gets deletion for free instead of reimplementing the
+    same atomicity/disjointness guarantees `write_tuples()` already provides.
+
+    Example:
+        store.write_tuples(Mutation(additions=frozenset({t}), deletions=frozenset()))
+        store.delete_tuples(frozenset({t}))
+    """
+
+    @abstractmethod
+    def write_tuples(self, mutation: Mutation) -> None:
+        """
+        Atomically applies a mutation's additions and deletions.
+
+        See `docs/semantics.md` § Write mutations for the full contract
+        (atomicity, idempotency, visibility point) — this method's
+        implementation must satisfy it, this docstring does not restate it.
+        """
+        raise NotImplementedError
+
+    def delete_tuples(self, tuples: frozenset[Tuple]) -> None:
+        """
+        Deletes the given tuples atomically, as a deletion-only Mutation.
+        """
+        self.write_tuples(Mutation(additions=frozenset(), deletions=tuples))
+
+    @abstractmethod
+    def snapshot(self) -> AbstractContextManager["View"]:
+        """
+        Opens an evaluation-scoped, read-only view pinned to one consistent snapshot.
+
+        See `docs/semantics.md` § Snapshot consistency of check() — every
+        read issued through the same `View` must observe the same logical
+        store state for the view's whole lifetime.
+        """
+        raise NotImplementedError
+
+
+class View(ABC):
+    """
+    Read-only handle pinned to one consistent snapshot of a `TupleStore`.
+
+    No write method exists here at all — `docs/semantics.md` already
+    decided mutations are issued against `TupleStore` itself, never through
+    a view; this class makes that an actual absence of a method, not just a
+    sentence in a doc.
+
+    Example:
+        with store.snapshot() as view:
+            view.read_tuple(subject, "owner", object)
+            view.read_relation(object, "owner", limit=100)
+    """
+
+    @abstractmethod
+    def read_tuple(self, subject: Subject, relation: str, object: ObjectReference) -> bool:
+        """
+        Returns whether the exact tuple `(subject, relation, object)` exists in this view.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def read_relation(self, object: ObjectReference, relation: str, limit: int) -> ReadResult:
+        """
+        Enumerates subjects/usersets holding `relation` on `object`, bounded by `limit`.
+
+        See `ReadResult`'s docstring for what `complete=False` means and
+        when it is set. An adapter must not materialize more than
+        `limit + 1` matching tuples before returning — that would violate the contract.
+        """
+        raise NotImplementedError

policy_pattern-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: policy-pattern
+Version: 0.1.0
+Summary: A minimal, embeddable ReBAC authorization engine for Python, inspired by Google Zanzibar.
+Keywords: python,authorization,access-control,rebac,zanzibar,security
+Author: Guillem Pozo Sebastián
+Author-email: Guillem Pozo Sebastián <58363308+guillem-ps@users.noreply.github.com>
+License-Expression: Apache-2.0
+License-File: LICENSE.md
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/guillem-ps/policy-pattern
+Project-URL: Repository, https://github.com/guillem-ps/policy-pattern
+Project-URL: Issues, https://github.com/guillem-ps/policy-pattern/issues
+Description-Content-Type: text/markdown
+
+# policy-pattern
+
+> A small, embeddable ReBAC authorization engine for Python, inspired by Google Zanzibar.
+
+<p align="center">
+    <a href="https://github.com/guillem-ps/policy-pattern/actions/workflows/test.yaml" target="_blank">
+        <img src="https://github.com/guillem-ps/policy-pattern/actions/workflows/test.yaml/badge.svg" alt="Test Pipeline">
+    </a>
+    <a href="https://github.com/guillem-ps/policy-pattern/actions/workflows/lint.yaml" target="_blank">
+        <img src="https://github.com/guillem-ps/policy-pattern/actions/workflows/lint.yaml/badge.svg" alt="Lint Pipeline">
+    </a>
+    <a href="https://codecov.io/gh/guillem-ps/policy-pattern" target="_blank">
+        <img src="https://codecov.io/gh/guillem-ps/policy-pattern/graph/badge.svg" alt="Coverage Pipeline">
+    </a>
+    <a href="pyproject.toml" target="_blank">
+        <img src="https://img.shields.io/badge/version-0.1.0-blue" alt="Package Version">
+    </a>
+    <a href="pyproject.toml" target="_blank">
+        <img src="https://img.shields.io/badge/python-3.12%20%7C%203.13%20%7C%203.14-blue" alt="Supported Python Versions">
+    </a>
+</p>
+
+`policy-pattern` is a standalone Python library for relationship-based access control (ReBAC). It models
+authorization as relationships between subjects and objects and evaluates those relationships through composable
+authorization rules.
+
+- **No authorization server**
+- **No required framework**
+- **No required database**
+- **No network hop**
+
+The library is designed to be embedded directly into Python applications that need richer authorization semantics
+than traditional role-based access control.
+
+> **Status:** v1 is code-complete — model, `compile()`, the storage port, `MemoryTupleStore`, and the `Evaluator`
+> all exist and are tested.
+
+See [Architecture § Scope](docs/architecture.md#scope) for what's planned (v1.x/v2) and unscheduled ideas.
+
+---
+
+## Table of Contents
+
+* [Example](#example)
+* [Documentation](#documentation)
+* [Contributing](#contributing)
+* [License](#license)
+* [References](#references)
+
+---
+
+## Example
+
+```python
+model = Model()
+model.types["document"] = Type(
+    name="document",
+    relations={
+        "owner": Relation(allowed_subject_types=("user",)),
+        "parent": Relation(allowed_subject_types=("folder",)),
+    },
+    permissions={
+        "viewer": Union(left=Reference(name="owner"), right=TupleToUserset(tupleset="parent", computed="viewer")),
+    },
+)
+compiled = model.compile()
+
+evaluator = Evaluator(model=compiled, store=store)
+evaluator.check(alice, "viewer", document_42)
+```
+
+`viewer` here means "the document's own owner, or the owner of whatever folder it lives in" — a document under
+`folder:engineering` inherits access from that folder without copying a permission onto every document.
+
+See the [Usage Guide](docs/usage/README.md) for the full, runnable walkthrough — every rewrite operator, nested
+groups, `EvaluationBudget`, and error handling.
+
+---
+
+## Documentation
+
+The repository uses specifications and architecture documents as part of the implementation contract — they
+describe **what must be true**, independent of any one adapter's implementation.
+
+```text
+docs/
+├── README.md        — documentation index, start here
+├── usage/README.md  — worked examples for every rewrite operator, budgets, error handling
+├── architecture.md  — the model shape, compile(), the storage port, the evaluator, and scope/roadmap
+├── semantics.md     — the storage contract every TupleStore adapter must satisfy
+└── errors.md        — the PPxxx error code ranges and what each one means
+```
+
+Start with the [Usage Guide](docs/usage/README.md) to see the library working end to end, then
+[Architecture](docs/architecture.md) to understand why the model is shaped the way it is.
+
+---
+
+## Contributing
+
+We love community help! Before you open an issue or pull request, please read:
+
+* [How to Contribute](.github/CONTRIBUTING.md)
+* [Code of Conduct](.github/CODE_OF_CONDUCT.md)
+* [Security Policy](SECURITY.md)
+
+---
+
+## License
+
+Licensed under the [Apache License 2.0](LICENSE.md).
+
+---
+
+## References
+
+The design is influenced by authorization systems and literature including:
+
+* [Google Zanzibar](https://research.google/pubs/zanzibar-googles-consistent-global-authorization-system/)
+* [OpenFGA](https://openfga.dev)
+* [SpiceDB](https://github.com/authzed/spicedb) / [AuthZed](https://authzed.com)
+
+`policy-pattern` is an independent project and is not an implementation of, or affiliated with, those projects.

policy_pattern-0.1.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+policy_pattern/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+policy_pattern/adapters/__init__.py,sha256=J2GWAI4H1SoveZ9ocF6D2Cg-aozMtKlKV_pDKs2Jq3o,69
+policy_pattern/adapters/memory.py,sha256=wFWt5P6QJxtqkz7onuYdCt8-ISz9FoVj77VvUb_8G0U,5027
+policy_pattern/errors/__init__.py,sha256=iJye0Mnn6n6JcN630fTCv5bxhFw5syV3Hs4eu-FD2D0,603
+policy_pattern/errors/base_error.py,sha256=aXuhBzC0s2vMPcVy8OTXYuS17Pjhz9eCYQag0FbCJcY,967
+policy_pattern/errors/evaluation_error.py,sha256=nB1sD5uL5FYxwXFgA28tE38XnKuSSu8CdmUdGzowQZw,463
+policy_pattern/errors/identifier_error.py,sha256=Rd8dhzIKKCjAm46wjsJIJA7AVsjs3NhWrlJZ9csqRpQ,320
+policy_pattern/errors/model_validation_error.py,sha256=LavYcAyQpqHJKoaCtXG_TC0Qv9zmyCTAeCerWHVrvj8,339
+policy_pattern/errors/mutation_error.py,sha256=kazfo30ma3ZZq1LvOcjZK4esMUzxphB4n6hrSL9hmjk,314
+policy_pattern/errors/relation_error.py,sha256=kWV-yxr7I-EmtHL3xnEqrTrkYNNU44bGswhwoV56W9c,314
+policy_pattern/errors/unknown_name_error.py,sha256=2jzHRzlQSF4K3OL9oS2aGlS08EiKBSIIEIbzpZfi1GU,445
+policy_pattern/errors/unknown_type_error.py,sha256=huIxIJVM1p6ngqdzq7sN9CQXY7shmhvSunZsb09y9Wk,446
+policy_pattern/evaluator.py,sha256=KmM4RSfZ4fV2Ft2IJ37Wpt5-me3JI-lhKwyDwiVmSgM,12211
+policy_pattern/models/__init__.py,sha256=pGhe4AnuH4Em9Iz9lpGL2hflt-ko1OshLSmrvWNs0Tg,837
+policy_pattern/models/_schema_validation.py,sha256=W712R6iBQ4rM0HvqUOyXpqy5X5ys2vKRMzqdKdscMYw,6140
+policy_pattern/models/compiled_model.py,sha256=Q00lhNwGl1jLlEuqbc57MZIKs5haJdKgp_qLjSPq28w,1581
+policy_pattern/models/direct_subject.py,sha256=Q-77hHX5Hk3VMZGuFDK6uQJIX3k2Yoe_LMGstAyupfU,1889
+policy_pattern/models/identifier.py,sha256=Jyt2oXiX2fWQW31UPFJXVnfVq7wCnseJg0DrJeemDYQ,1747
+policy_pattern/models/model.py,sha256=2PdajMGKppBeRRnzRjyIOR-S1lWzBLfAGAvkT15X8Ro,1739
+policy_pattern/models/mutation.py,sha256=B5IbfaTdvwvmrBQtXrciBFfe5qHGt0DCOYRgC2zdiKY,1660
+policy_pattern/models/object_reference.py,sha256=r7tErTsOkFZSJk3gHXMRL2txiv1cyQdPRpT_nkcOWDY,1240
+policy_pattern/models/operators.py,sha256=tVVBwWloJ2mL9aKpqjZERBO2MjuAhT0Kv1FfUFcEgCI,4337
+policy_pattern/models/reference.py,sha256=WFbZ8TVukEleDbIpS32lWNMYC6jfxqimiYDyuvbsTRo,1252
+policy_pattern/models/relation.py,sha256=xGz4GxfboiRf1i3HJe-1bAR4iFMViVc656Ykob-iCro,1473
+policy_pattern/models/subject.py,sha256=isIXEWD2j1YCCyCn4C46Ffa7QSSd0saQ6rmr-9Uuoo4,1052
+policy_pattern/models/subject_set.py,sha256=lRrOyP_SWPbACxs9rityDa1P570qGvSlZDxon0xmHUA,2089
+policy_pattern/models/tuple.py,sha256=ty5dcn9mBpWlZlJlVAcwG1MaGxIyq1MzeSJRvoWw_WA,1790
+policy_pattern/models/tuple_to_userset.py,sha256=IMGlZG5tJOHai1sddxMIM-4TbJwFMdJ8xE2B0Y1wPC8,2055
+policy_pattern/models/type.py,sha256=98cXOUOkTU1XEpLKWk18MS-Xzn0psWMDh8Jm6ykvKJA,3048
+policy_pattern/ports/__init__.py,sha256=qAg-9xRvVCzP80kYf08R-Mk7GraLokQpg4WC28xhQiA,117
+policy_pattern/ports/tuple_store.py,sha256=qzHIlgUQVc5bHZPbu0NWJXoD8w2NV9XPBtHwoAzTbKw,4619
+policy_pattern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+policy_pattern-0.1.0.dist-info/licenses/LICENSE.md,sha256=pBo98b3diIHXZ6w8GMvFkU9_m_uIrPzHvUu9-vqIbTI,11353
+policy_pattern-0.1.0.dist-info/WHEEL,sha256=rp-k_VZaX8oABFEtLwG_Df95p8LSKt9-uPyQ4jKH0P4,81
+policy_pattern-0.1.0.dist-info/METADATA,sha256=mgX-g3yVTFMjZvPUqeW-tZdHJzStp5aWltr4asCIao0,5687
+policy_pattern-0.1.0.dist-info/RECORD,,

policy_pattern-0.1.0.dist-info/WHEEL

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