attack-on-domain 0.0.1__tar.gz

attack_on_domain-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 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.

attack_on_domain-0.0.1/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: attack-on-domain
+Version: 0.0.1
+Summary: DDD building blocks: entities, value objects, bounded contexts, and validation helpers.
+Author: Alfonso Cuesta
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/AlfonsoCuesta/attack-on-domain
+Project-URL: Repository, https://github.com/AlfonsoCuesta/attack-on-domain
+Project-URL: Issues, https://github.com/AlfonsoCuesta/attack-on-domain/issues
+Keywords: ddd,domain-driven-design,entity,value-object
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: typing-inspect>=0.9.0
+Dynamic: license-file
+
+# attack-on-domain
+
+Helpers for **domain-driven design** in Python: entities, value objects, bounded contexts, domain events, and Pydantic v2–based validation.
+
+## Install
+
+```bash
+pip install attack-on-domain
+```
+
+With **uv** in another project:
+
+```bash
+uv add attack-on-domain
+```
+
+Or install into the active environment:
+
+```bash
+uv pip install attack-on-domain
+```
+
+## Usage
+
+Import only from the top-level package:
+
+```python
+from aod import (
+    BoundedContext,
+    DomainEvent,
+    DomainException,
+    Entity,
+    ValueObject,
+)
+```
+
+Requires **Python 3.14+**.

attack_on_domain-0.0.1/README.md

@@ -0,0 +1,37 @@
+# attack-on-domain
+
+Helpers for **domain-driven design** in Python: entities, value objects, bounded contexts, domain events, and Pydantic v2–based validation.
+
+## Install
+
+```bash
+pip install attack-on-domain
+```
+
+With **uv** in another project:
+
+```bash
+uv add attack-on-domain
+```
+
+Or install into the active environment:
+
+```bash
+uv pip install attack-on-domain
+```
+
+## Usage
+
+Import only from the top-level package:
+
+```python
+from aod import (
+    BoundedContext,
+    DomainEvent,
+    DomainException,
+    Entity,
+    ValueObject,
+)
+```
+
+Requires **Python 3.14+**.

attack_on_domain-0.0.1/code/aod/__init__.py

@@ -0,0 +1,21 @@
+"""
+Public API for the aod library.
+
+Supported imports: ``from aod import …`` only. The ``_internal`` package
+exists for packaging layout only; it is not a semver-stable API surface.
+"""
+
+from aod._internal.core.domain_exception import DomainException
+from aod._internal.core.event_emitter import Event as DomainEvent
+from aod._internal.domain.bounded_context import BoundedContext
+from aod._internal.domain.entity import Entity, RootEntity
+from aod._internal.domain.value_object import ValueObject
+
+__all__ = [
+    "BoundedContext",
+    "DomainEvent",
+    "DomainException",
+    "Entity",
+    "RootEntity",
+    "ValueObject",
+]

attack_on_domain-0.0.1/code/aod/_internal/__init__.py

@@ -0,0 +1 @@
+"""Implementation modules; not part of the supported public API."""

attack_on_domain-0.0.1/code/aod/_internal/core/__main__.py

@@ -0,0 +1,64 @@
+from typing import Annotated, Any, Self
+
+from .base_inmutable import BaseInmutable
+from .base_mutable import BaseMutable
+from .base_validator import BaseValidator
+from .fields.fields import Field, PrivateField
+from .validators import (
+    AfterValidator,
+    field_validator,
+    post_init,
+)
+
+print(BaseValidator)
+print(BaseMutable)
+
+
+def text(value: Any) -> str:
+    return "Hola"
+
+
+def main() -> None:
+    class Prueba:
+        def __init__(self, a: int) -> None:
+            self.a = a
+
+    class User(BaseMutable):
+        age: int = 0
+        _prueba: int = PrivateField()
+
+        @field_validator("age")
+        def is_even(cls, value: int) -> int:
+            return 22
+
+        @post_init
+        def validate_age(self) -> Self:
+            return self
+
+    class User2(User):
+        a: int = Field()
+        text: Annotated[str, AfterValidator(text)]
+        prueba_attr: Prueba
+
+        def change_text(self, text: str) -> None:
+            self.text = text
+
+        def can_mutate(self) -> bool:
+            return self.text != "Adio"
+
+        def prueba(self) -> None:
+            print("prueba")
+
+    prueba = Prueba(a=1)
+    a = User2(text="Adio", age=2, a=1, prueba_attr=prueba)
+
+    class User3(BaseInmutable):
+        age: int = 0
+
+    user3 = User3(age=1)
+    print(user3)
+    user3.age = 2
+
+
+if __name__ == "__main__":
+    main()

attack_on_domain-0.0.1/code/aod/_internal/core/base_inmutable.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+from .base_validator import BaseValidator
+from .domain_exception import MutationForbiddenError
+
+
+class BaseInmutable(BaseValidator):
+    __initialized__: bool = False
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if self.__initialized__:
+            raise MutationForbiddenError()
+        super().__setattr__(name, value)
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.__initialized__ = True

attack_on_domain-0.0.1/code/aod/_internal/core/base_mutable.py

@@ -0,0 +1,117 @@
+import inspect
+from contextlib import contextmanager
+from enum import StrEnum
+from functools import wraps
+from typing import Any, Callable, Generator, Literal, Type, cast
+
+from .base_validator import BaseValidator, PydanticFacadeMeta
+from .domain_exception import MutationForbiddenError
+
+
+class MutatingState(StrEnum):
+    BLOCK = "block"
+    PASS = "pass"
+    SUPER = "super"
+
+
+class MutatingContext:
+    def __init__(self):
+        self._deep_states = {
+            MutatingState.PASS: 0,
+            MutatingState.SUPER: 0,
+        }
+
+    def enter(
+        self, state: Literal[MutatingState.PASS, MutatingState.SUPER]
+    ) -> None:
+        self._deep_states[state] += 1
+
+    def exit(
+        self, state: Literal[MutatingState.PASS, MutatingState.SUPER]
+    ) -> None:
+        self._deep_states[state] -= 1 if self._deep_states[state] > 0 else 0
+
+    @property
+    def status(
+        self,
+    ) -> Literal[MutatingState.BLOCK, MutatingState.PASS, MutatingState.SUPER]:
+        return (
+            MutatingState.SUPER
+            if self._deep_states[MutatingState.SUPER] > 0
+            else MutatingState.PASS
+            if self._deep_states[MutatingState.PASS] > 0
+            else MutatingState.BLOCK
+        )
+
+
+class MutableBaseMeta(PydanticFacadeMeta):
+    NOT_MUTABLE_CALLABLES = {
+        "can_mutate",
+        "_get_mutating_context",
+    }
+
+    def __new__(mcls, name, bases, namespace):
+
+        cls = super().__new__(mcls, name, bases, namespace)
+
+        def mutate(fn: Callable) -> Callable:
+            @wraps(fn)
+            def wrapper(self: BaseMutable, *args: Any, **kwargs: Any) -> Any:
+                super_mutate = fn.__name__.startswith("_")
+                with self.__mutate__(super_mutate=super_mutate):
+                    return fn(self, *args, **kwargs)
+
+            setattr(wrapper, "__mutable__", True)
+
+            return wrapper
+
+        for base in cls.__mro__:
+            for attr_name, attr_value in base.__dict__.items():
+                if attr_name.startswith("__") and attr_name.endswith("__"):
+                    continue
+                if attr_name in cls.NOT_MUTABLE_CALLABLES or getattr(
+                    attr_value, "__mutable__", False
+                ):
+                    continue
+                if not inspect.isfunction(attr_value):
+                    continue
+                setattr(cls, attr_name, mutate(attr_value))
+        return cls
+
+
+class BaseMutable(BaseValidator, metaclass=MutableBaseMeta):
+    __mutating_context__: MutatingContext | None = None
+    __mutating_context_class__: Type[MutatingContext] = MutatingContext
+
+    def can_mutate(self) -> bool:
+        return True
+
+    def _get_mutating_context(self) -> MutatingContext:
+        if self.__mutating_context__ is None:
+            object.__setattr__(
+                self, "__mutating_context__", self.__mutating_context_class__()
+            )
+        return cast(MutatingContext, self.__mutating_context__)
+
+    @contextmanager
+    def __mutate__(
+        self, super_mutate: bool = False
+    ) -> Generator[None, None, None]:
+        mutating_context = self._get_mutating_context()
+        mutation: Literal[MutatingState.PASS, MutatingState.SUPER] = (
+            MutatingState.SUPER if super_mutate else MutatingState.PASS
+        )
+        mutating_context.enter(mutation)
+        yield
+        mutating_context.exit(mutation)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        mutating_status = self._get_mutating_context().status
+        super_mutate = mutating_status == MutatingState.SUPER
+        pass_mutate = (
+            mutating_status == MutatingState.PASS and self.can_mutate()
+        )
+        can_mutate = super_mutate or pass_mutate
+        if not can_mutate:
+            raise MutationForbiddenError()
+        super().__setattr__(name, value)

attack_on_domain-0.0.1/code/aod/_internal/core/base_validator.py

@@ -0,0 +1,60 @@
+import inspect
+from typing import Any, ClassVar, Self, Type, dataclass_transform
+
+from pydantic import BaseModel
+
+from .fields import Field
+from .model_maker import (
+    RAW_MODEL_KEY,
+    VALIDATION_MODEL_KEY,
+    make_raw_model,
+    make_validation_model,
+)
+
+
+class PydanticFacadeMeta(type):
+    def __new__(mcls, name, bases, namespace):
+        cls = super().__new__(mcls, name, bases, namespace)
+
+        validation_model = make_validation_model(cls, name, bases)
+        raw_model = make_raw_model(cls, name, bases)
+
+        setattr(cls, VALIDATION_MODEL_KEY, validation_model)
+        setattr(cls, RAW_MODEL_KEY, raw_model)
+
+        cls.__init__.__signature__ = inspect.signature(validation_model)
+
+        return cls
+
+
+@dataclass_transform(field_specifiers=(Field,), kw_only_default=True)
+class BaseValidator(metaclass=PydanticFacadeMeta):
+    __validation_model__: ClassVar[Type[BaseModel]]
+    __raw_model__: ClassVar[Type[BaseModel]]
+
+    def __init__(self, **kwargs: Any) -> None:
+        model = self.__class__.__validation_model__
+        validated = model(**kwargs)
+
+        self._set_model_attributes(validated)
+
+    def _set_model_attributes(self, validated: BaseModel) -> None:
+        for k, v in validated.model_dump().items():
+            setattr(self, k, v)
+
+        private = getattr(validated, "__pydantic_private__", {})
+        if private:
+            for k, v in private.items():
+                setattr(self, k, v)
+
+    def __repr__(self):
+        fields = self.__validation_model__.model_fields.keys()
+        args = ", ".join(f"{k}={getattr(self, k)!r}" for k in fields)
+        return f"{self.__class__.__name__}({args})"
+
+    @classmethod
+    def from_existing(cls, **kwargs) -> Self:
+        object = cls.__raw_model__(**kwargs)
+        instance = cls.__new__(cls)
+        instance._set_model_attributes(object)
+        return instance

attack_on_domain-0.0.1/code/aod/_internal/core/domain_exception.py

@@ -0,0 +1,41 @@
+class DomainException(Exception):
+    """Base for errors raised by domain rules and related guards."""
+
+    pass
+
+
+class MutationForbiddenError(DomainException):
+    """Raised when a mutable or immutable object is updated outside allowed context."""
+
+    def __init__(self, message: str = "Cannot mutate this object") -> None:
+        super().__init__(message)
+
+
+class InvalidEntityTypeError(DomainException):
+    """Raised when a type registered as aggregate root is not an Entity subclass."""
+
+    def __init__(self, type_name: str) -> None:
+        super().__init__(f"{type_name} is not an Entity")
+
+
+class InvalidRootEntityTypeError(DomainException):
+    """Raised when a type is an Entity but not declared as aggregate root."""
+
+    def __init__(self, type_name: str) -> None:
+        super().__init__(f"{type_name} is not a root Entity")
+
+
+class InvalidServiceTypeError(DomainException):
+    """Raised when a type registered as service is not a Service subclass."""
+
+    def __init__(self, type_name: str) -> None:
+        super().__init__(f"{type_name} is not a Service")
+
+
+class ClassExpectedError(DomainException):
+    """Raised when a class was required but a non-type value was given."""
+
+    def __init__(self, *, role: str, got: object) -> None:
+        super().__init__(
+            f"Expected a class for {role}, got {type(got).__name__} instance"
+        )

attack_on_domain-0.0.1/code/aod/_internal/core/event_emitter.py

@@ -0,0 +1,23 @@
+from datetime import datetime, timezone
+from typing import List, Protocol, runtime_checkable
+
+from .base_inmutable import BaseInmutable
+from .fields.fields import Field
+
+
+class Event(BaseInmutable):
+    emmited_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), init=False
+    )
+
+
+@runtime_checkable
+class EventEmitter(Protocol):
+    def _emit(self, event: Event) -> None:
+        pass
+
+    def _clear_events(self) -> None:
+        pass
+
+    def poll_events(self) -> List[Event]:
+        pass

attack_on_domain-0.0.1/code/aod/_internal/core/fields/__init__.py

@@ -0,0 +1,3 @@
+from .fields import Field, PrivateField
+
+__all__ = ["Field", "PrivateField"]

attack_on_domain-0.0.1/code/aod/_internal/core/fields/fields.py

@@ -0,0 +1,94 @@
+import re
+from typing import Any, Callable, overload
+
+import annotated_types
+from pydantic import Field as PField
+from pydantic import PrivateAttr
+
+
+class Unset:
+    def __repr__(self) -> str:
+        return "UNSET FIELD"
+
+
+@overload
+def Field(
+    default: Any,
+    *,
+    default_factory: Callable[[], Any] | None = ...,
+    gt: annotated_types.SupportsGt | None = ...,
+    ge: annotated_types.SupportsGe | None = ...,
+    lt: annotated_types.SupportsLt | None = ...,
+    le: annotated_types.SupportsLe | None = ...,
+    multiple_of: float | None = ...,
+    strict: bool | None = ...,
+    min_length: int | None = ...,
+    max_length: int | None = ...,
+    pattern: str | re.Pattern[str] | None = ...,
+    allow_inf_nan: bool | None = ...,
+    max_digits: int | None = ...,
+    decimal_places: int | None = ...,
+    init: bool = True,
+) -> Any: ...
+
+
+@overload
+def Field(
+    *,
+    default_factory: Callable[[], Any],
+    gt: annotated_types.SupportsGt | None = ...,
+    ge: annotated_types.SupportsGe | None = ...,
+    lt: annotated_types.SupportsLt | None = ...,
+    le: annotated_types.SupportsLe | None = ...,
+    multiple_of: float | None = ...,
+    strict: bool | None = ...,
+    min_length: int | None = ...,
+    max_length: int | None = ...,
+    pattern: str | re.Pattern[str] | None = ...,
+    allow_inf_nan: bool | None = ...,
+    max_digits: int | None = ...,
+    decimal_places: int | None = ...,
+    init: bool = True,
+) -> Any: ...
+
+
+@overload
+def Field(
+    *,
+    gt: annotated_types.SupportsGt | None = ...,
+    ge: annotated_types.SupportsGe | None = ...,
+    lt: annotated_types.SupportsLt | None = ...,
+    le: annotated_types.SupportsLe | None = ...,
+    multiple_of: float | None = ...,
+    strict: bool | None = ...,
+    min_length: int | None = ...,
+    max_length: int | None = ...,
+    pattern: str | re.Pattern[str] | None = ...,
+    allow_inf_nan: bool | None = ...,
+    max_digits: int | None = ...,
+    decimal_places: int | None = ...,
+    init: bool = True,
+) -> Any: ...
+
+
+def Field(default: Any = ..., **kwargs: Any) -> Any:
+    return PField(default, **kwargs)
+
+
+@overload
+def PrivateField(
+    default: Any = ..., *, default_factory: None = None
+) -> Any: ...
+
+
+@overload
+def PrivateField(*, default_factory: Callable[[], Any]) -> Any: ...
+
+
+def PrivateField(
+    default: Any = ..., *, default_factory: Callable[[], Any] | None = None
+) -> Any:
+    if default_factory is not None:
+        return PrivateAttr(default_factory=default_factory, init=False)
+    field_default = Unset() if default is ... else default
+    return PrivateAttr(default=field_default, init=False)

attack_on_domain-0.0.1/code/aod/_internal/core/model_maker.py

@@ -0,0 +1,75 @@
+from typing import Annotated, Any, Type, get_args, get_origin
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.fields import ModelPrivateAttr
+
+from .validators import is_validator
+
+VALIDATION_MODEL_KEY = "__validation_model__"
+RAW_MODEL_KEY = "__raw_model__"
+
+
+def get_parent_models(
+    bases: tuple[Type[Any], ...], key: str
+) -> tuple[Type[Any], ...]:
+    parent_models = tuple(getattr(b, key) for b in bases if hasattr(b, key))
+    if not parent_models:
+        parent_models = (BaseModel,)
+    return parent_models
+
+
+def get_model_config(cls: Type[Any]) -> ConfigDict:
+    existing_config = getattr(cls, "model_config", None)
+    if isinstance(existing_config, dict):
+        return ConfigDict(**existing_config, arbitrary_types_allowed=True)
+    return ConfigDict(arbitrary_types_allowed=True)
+
+
+def make_validation_model(
+    cls: Type[Any],
+    name: str,
+    bases: tuple[Type[Any], ...],
+) -> Type[BaseModel]:
+    full_ns = {
+        "model_config": get_model_config(cls),
+        "__module__": cls.__module__,
+        "__qualname__": f"{cls.__qualname__}.{name}ValidationModel",
+        "__annotations__": cls.__annotations__,
+        **{k: getattr(cls, k) for k in cls.__annotations__ if hasattr(cls, k)},
+    }
+    for k, v in cls.__dict__.copy().items():
+        if validator_info := is_validator(v):
+            full_ns[k] = validator_info(v)
+
+    parent_models = get_parent_models(bases, VALIDATION_MODEL_KEY)
+    return type(name + "ValidationModel", parent_models, full_ns)
+
+
+def strip_validators(annotation):
+    if get_origin(annotation) is Annotated:
+        return get_args(annotation)[0]
+    return annotation
+
+
+def make_raw_model(
+    cls: Type[Any],
+    name: str,
+    bases: tuple[Type[Any], ...],
+) -> Type[BaseModel]:
+    annotations = {
+        k: strip_validators(v) for k, v in cls.__annotations__.items()
+    }
+    ns: dict[str, Any] = {
+        "model_config": get_model_config(cls),
+        "__module__": cls.__module__,
+        "__qualname__": f"{cls.__qualname__}.{name}RawModel",
+        "__annotations__": annotations,
+    }
+
+    for base in reversed(cls.__mro__):
+        for k, v in getattr(base, "__dict__", {}).items():
+            if isinstance(v, ModelPrivateAttr):
+                ns[k] = v
+
+    parent_models = get_parent_models(bases, RAW_MODEL_KEY)
+    return type(name + "RawModel", parent_models, ns)

attack_on_domain-0.0.1/code/aod/_internal/core/validators/__init__.py

@@ -0,0 +1,15 @@
+from pydantic import AfterValidator, BeforeValidator
+
+from .validators import (
+    field_validator,
+    is_validator,
+    post_init,
+)
+
+__all__ = [
+    "AfterValidator",
+    "BeforeValidator",
+    "field_validator",
+    "is_validator",
+    "post_init",
+]

attack_on_domain-0.0.1/code/aod/_internal/core/validators/validators.py

@@ -0,0 +1,59 @@
+from typing import Callable, Literal
+
+from pydantic import (
+    field_validator as pydantic_field_validator,
+)
+from pydantic import (
+    model_validator as pydantic_model_validator,
+)
+
+VALIDATOR_KEY = "__field_validator_info__"
+
+
+class ValidatorInfo:
+    def __init__(self, *args, validation: Callable, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+        self.validation = validation
+
+    def __call__(self, fn):
+        return self.validation(*self.args, **self.kwargs)(fn)
+
+
+def field_validator(
+    *fields,
+    mode: Literal["before", "after"] = "before",
+    check_fields: bool = False,
+):
+    def decorator(fn):
+        if not isinstance(fn, classmethod):
+            fn = classmethod(fn)
+        setattr(
+            fn,
+            VALIDATOR_KEY,
+            ValidatorInfo(
+                validation=pydantic_field_validator,
+                *fields,
+                mode=mode,
+                check_fields=check_fields,
+            ),
+        )
+        return fn
+
+    return decorator
+
+
+def post_init(fn):
+    setattr(
+        fn,
+        VALIDATOR_KEY,
+        ValidatorInfo(validation=pydantic_model_validator, mode="after"),
+    )
+    return fn
+
+
+def is_validator(fn) -> ValidatorInfo | None:
+    has_key = getattr(fn, VALIDATOR_KEY, None)
+    if not has_key and isinstance(fn, classmethod):
+        has_key = getattr(fn.__func__, VALIDATOR_KEY, None)
+    return has_key

attack_on_domain-0.0.1/code/aod/_internal/domain/__init__.py

@@ -0,0 +1,6 @@
+from .bounded_context import BoundedContext
+from .entity import Entity, RootEntity
+from .service import Service
+from .value_object import ValueObject
+
+__all__ = ["BoundedContext", "Entity", "RootEntity", "Service", "ValueObject"]

attack_on_domain-0.0.1/code/aod/_internal/domain/bounded_context.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Iterable, Optional, TypeAlias
+
+from aod._internal.core.domain_exception import (
+    ClassExpectedError,
+    InvalidEntityTypeError,
+    InvalidRootEntityTypeError,
+    InvalidServiceTypeError,
+)
+
+from .entity import Entity, RootEntity
+from .service import Service
+
+RootEntityType: TypeAlias = type[RootEntity]
+ServiceType: TypeAlias = type[Service]
+
+
+class BoundedContext:
+    """
+    A bounded context defined by its aggregate roots.
+
+    This class expects a collection of *entity classes*, not instances.
+    """
+
+    def __init__(
+        self,
+        aggregate_roots: Optional[Iterable[RootEntityType]] = None,
+        services: Optional[Iterable[ServiceType]] = None,
+    ):
+        if aggregate_roots is None:
+            aggregate_roots = []
+        if services is None:
+            services = []
+
+        for item in aggregate_roots:
+            if not isinstance(item, type):
+                raise ClassExpectedError(role="aggregate root", got=item)
+            if not issubclass(item, Entity):
+                raise InvalidEntityTypeError(item.__name__)
+            if not item.is_root():
+                raise InvalidRootEntityTypeError(item.__name__)
+
+        for service in services:
+            if not isinstance(service, type):
+                raise ClassExpectedError(role="service", got=service)
+            if not issubclass(service, Service):
+                raise InvalidServiceTypeError(service.__name__)
+
+        self.aggregate_roots: tuple[RootEntityType, ...] = tuple(
+            aggregate_roots
+        )
+        self.services: tuple[ServiceType, ...] = tuple(services)

attack_on_domain-0.0.1/code/aod/_internal/domain/entity.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import ClassVar, Generator, List
+
+from aod._internal.core.base_mutable import BaseMutable, MutableBaseMeta
+from aod._internal.core.event_emitter import Event, EventEmitter
+from aod._internal.core.fields import PrivateField
+
+
+class EntityMeta(MutableBaseMeta):
+    def __new__(mcls, name, bases, namespace, root=None):
+        cls = super().__new__(mcls, name, bases, namespace)
+        if root is not None:
+            cls.__aggregate_root__ = bool(root)
+        return cls
+
+
+class Entity(BaseMutable, metaclass=EntityMeta):
+    __aggregate_root__: ClassVar[bool] = False
+    _events: List[Event] = PrivateField(default_factory=list)
+
+    @classmethod
+    def is_root(cls) -> bool:
+        return cls.__aggregate_root__
+
+    def _emit(self, event: Event) -> None:
+        self._events.append(event)
+
+    def poll_events(self) -> List[Event]:
+        events: list[Event] = list(self._events)
+
+        for emitter in self._self_emitters():
+            events.extend(emitter.poll_events())
+
+        events.sort(key=lambda e: e.emmited_at)
+        return events
+
+    def _clear_events(self) -> None:
+        self._events.clear()
+
+        for emitter in self._self_emitters():
+            emitter._clear_events()
+
+    def _self_emitters(self) -> Generator[EventEmitter, None, None]:
+        for emitter in vars(self).values():
+            if isinstance(emitter, EventEmitter):
+                yield emitter
+
+
+class RootEntity(Entity, root=True):
+    pass

attack_on_domain-0.0.1/code/aod/_internal/domain/service.py

@@ -0,0 +1,3 @@
+class Service:
+    """Domain service base class (stateless operations / coordination)."""
+

attack_on_domain-0.0.1/code/aod/_internal/domain/value_object.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import List
+
+from aod._internal.core.base_inmutable import BaseInmutable
+from aod._internal.core.event_emitter import Event
+from aod._internal.core.fields import PrivateField
+
+
+class ValueObject(BaseInmutable):
+    """Domain Value Object base (immutable) with domain events."""
+
+    _events: List[Event] = PrivateField(default_factory=list)
+
+    def _emit(self, event: Event) -> None:
+        self._events.append(event)
+
+    def _clear_events(self) -> None:
+        self._events.clear()
+
+    def poll_events(self) -> List[Event]:
+        return list(self._events)

attack_on_domain-0.0.1/code/attack_on_domain.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: attack-on-domain
+Version: 0.0.1
+Summary: DDD building blocks: entities, value objects, bounded contexts, and validation helpers.
+Author: Alfonso Cuesta
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/AlfonsoCuesta/attack-on-domain
+Project-URL: Repository, https://github.com/AlfonsoCuesta/attack-on-domain
+Project-URL: Issues, https://github.com/AlfonsoCuesta/attack-on-domain/issues
+Keywords: ddd,domain-driven-design,entity,value-object
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: typing-inspect>=0.9.0
+Dynamic: license-file
+
+# attack-on-domain
+
+Helpers for **domain-driven design** in Python: entities, value objects, bounded contexts, domain events, and Pydantic v2–based validation.
+
+## Install
+
+```bash
+pip install attack-on-domain
+```
+
+With **uv** in another project:
+
+```bash
+uv add attack-on-domain
+```
+
+Or install into the active environment:
+
+```bash
+uv pip install attack-on-domain
+```
+
+## Usage
+
+Import only from the top-level package:
+
+```python
+from aod import (
+    BoundedContext,
+    DomainEvent,
+    DomainException,
+    Entity,
+    ValueObject,
+)
+```
+
+Requires **Python 3.14+**.

attack_on_domain-0.0.1/code/attack_on_domain.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+LICENSE
+README.md
+pyproject.toml
+code/aod/__init__.py
+code/aod/py.typed
+code/aod/_internal/__init__.py
+code/aod/_internal/core/__init__.py
+code/aod/_internal/core/__main__.py
+code/aod/_internal/core/base_inmutable.py
+code/aod/_internal/core/base_mutable.py
+code/aod/_internal/core/base_validator.py
+code/aod/_internal/core/domain_exception.py
+code/aod/_internal/core/event_emitter.py
+code/aod/_internal/core/model_maker.py
+code/aod/_internal/core/fields/__init__.py
+code/aod/_internal/core/fields/fields.py
+code/aod/_internal/core/validators/__init__.py
+code/aod/_internal/core/validators/validators.py
+code/aod/_internal/domain/__init__.py
+code/aod/_internal/domain/bounded_context.py
+code/aod/_internal/domain/entity.py
+code/aod/_internal/domain/service.py
+code/aod/_internal/domain/value_object.py
+code/attack_on_domain.egg-info/PKG-INFO
+code/attack_on_domain.egg-info/SOURCES.txt
+code/attack_on_domain.egg-info/dependency_links.txt
+code/attack_on_domain.egg-info/requires.txt
+code/attack_on_domain.egg-info/top_level.txt

attack_on_domain-0.0.1/code/attack_on_domain.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

attack_on_domain-0.0.1/code/attack_on_domain.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pydantic>=2.12.4
+typing-inspect>=0.9.0

attack_on_domain-0.0.1/code/attack_on_domain.egg-info/top_level.txt

@@ -0,0 +1 @@
+aod

attack_on_domain-0.0.1/pyproject.toml

@@ -0,0 +1,64 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "attack-on-domain"
+version = "0.0.1"
+description = "DDD building blocks: entities, value objects, bounded contexts, and validation helpers."
+readme = "README.md"
+requires-python = ">=3.14"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Alfonso Cuesta" },
+]
+keywords = ["ddd", "domain-driven-design", "entity", "value-object"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pydantic>=2.12.4",
+    "typing-inspect>=0.9.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AlfonsoCuesta/attack-on-domain"
+Repository = "https://github.com/AlfonsoCuesta/attack-on-domain"
+Issues = "https://github.com/AlfonsoCuesta/attack-on-domain/issues"
+
+[tool.setuptools.package-data]
+aod = ["py.typed"]
+
+[tool.setuptools.package-dir]
+"" = "code"
+
+[tool.setuptools.packages.find]
+where = ["code"]
+include = ["aod*"]
+exclude = ["tests*", "tests"]
+
+[dependency-groups]
+dev = [
+    "black>=25.11.0",
+    "mypy>=1.20.2",
+    "pre-commit>=4.4.0",
+    "pytest>=9.0.2",
+    "twine>=6.0.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["code"]
+testpaths = ["code/tests"]
+
+[tool.mypy]
+python_version = "3.14"
+mypy_path = ["code"]
+files = ["code"]
+explicit_package_bases = true

attack_on_domain-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+