sindripy 0.1.1__py3-none-any.whl

sindripy/value_objects/value_object.py

@@ -0,0 +1,269 @@
+from abc import ABC
+from collections.abc import Callable
+from typing import Generic, TypeVar
+
+from src.sindripy._compat import Self, override
+
+T = TypeVar("T")
+
+
+class ValueObject(ABC, Generic[T]):
+    """
+    Abstract base class for implementing value objects with immutability and validation.
+
+    Value objects are immutable objects that represent a descriptive aspect of the domain
+    with no conceptual identity. They are equal when their values are equal.
+
+    Type Parameters:
+        T: The type of the value being wrapped by this value object.
+
+    Attributes:
+        _value: The internal value stored by this value object.
+
+    Example:
+        ```python
+        from sindripy import ValueObject
+
+        class String(ValueObject[str]):
+            pass
+
+        string = String("Hello World")
+        repr(email)  # String(_value='Hello World')
+        ```
+    """
+
+    __slots__ = ("_value",)
+    __match_args__ = ("_value",)
+
+    _value: T
+
+    def __init__(self, value: T) -> None:
+        """
+        Initialize the value object with the given value.
+
+        The value is validated using all methods decorated with @validate before
+        being stored. Once initialized, the value cannot be modified.
+
+        Args:
+            value: The value to be wrapped by this value object.
+
+        Raises:
+            Various validation errors depending on the specific value object implementation.
+
+        Example:
+            from sindripy import ValueObject
+
+            class String(ValueObject[str]):
+                pass
+
+            string = String("Hello World")
+            repr(email)  # String(_value='Hello World')
+            ```
+        """
+        self._validate(value)
+        object.__setattr__(self, "_value", value)
+
+    def _validate(self, value: T) -> None:
+        """
+        Validates the given value using all methods decorated with @validate.
+
+        This method collects all validator methods from the class hierarchy (in reverse MRO order)
+        and executes them in the order specified by their _order attribute. All validators
+        must pass for the value to be considered valid.
+
+        Args:
+            value: The value to validate.
+
+        Raises:
+            Various validation errors if any validator fails.
+
+        Example:
+            ```python
+            class Username(ValueObject[str]):
+                @validate(order=1)
+                def _validate_not_empty(self, value: str) -> None:
+                    if not value.strip():
+                        raise ValueError("Username cannot be empty")
+
+                @validate(order=2)
+                def _validate_length(self, value: str) -> None:
+                    if len(value) < 3:
+                        raise ValueError("Username must be at least 3 characters")
+
+            username = Username("john")  # Both validators pass
+            username._validate("ab")  # Would raise ValueError for length
+            ```
+        """
+        validators: list[Callable[[T], None]] = []
+        for cls in reversed(self.__class__.__mro__):
+            if cls is object:
+                continue
+
+            methods: list[tuple[int, Callable[[T], None]]] = []
+            for name, member in cls.__dict__.items():
+                if getattr(member, "_is_validator", False):
+                    validators.append(getattr(self, name))
+                    order: int = getattr(member, "_order", 0)
+                    methods.append((order, getattr(self, name)))
+
+            for _, method in sorted(methods, key=lambda item: item[0]):
+                validators.append(method)
+
+        for validator in validators:
+            validator(value)
+
+    @property
+    def value(self) -> T:
+        """
+        Get the wrapped value.
+
+        Returns:
+            The value wrapped by this value object.
+
+        Example:
+            ```python
+            class ProductName(ValueObject[str]):
+                pass
+
+            product = ProductName("iPhone 15")
+            product.value  # 'iPhone 15'
+            type(product.value)  # <class 'str'>
+            ```
+        """
+        return self._value
+
+    @override
+    def __eq__(self, other: Self) -> bool:
+        """
+        Check equality with another value object of the same type.
+
+        Two value objects are considered equal if their wrapped values are equal.
+
+        Args:
+            other: Another value object of the same type to compare with.
+
+        Returns:
+            True if both value objects have equal values, False otherwise.
+
+        Example:
+            ```python
+            class UserId(ValueObject[int]):
+                pass
+
+            user1 = UserId(123)
+            user2 = UserId(123)
+            user3 = UserId(456)
+            user1 == user2  # True
+            user1 == user3  # False
+            user1 == 123  # Different type, would raise error
+            ```
+        """
+        if not isinstance(other, self.__class__):
+            return False
+
+        return self.value == other.value
+
+    @override
+    def __repr__(self) -> str:
+        """
+        Return a string representation suitable for debugging.
+
+        Returns:
+            A string in the format "ClassName(value)" that can be used to recreate the object.
+
+        Example:
+            ```python
+            class OrderId(ValueObject[str]):
+                pass
+
+            order = OrderId("ORD-001")
+            repr(order)  # "OrderId('ORD-001')"
+            eval(repr(order))  # OrderId('ORD-001')
+            ```
+        """
+        return f"{self.__class__.__name__}({self._value!r})"
+
+    @override
+    def __str__(self) -> str:
+        """
+        Return a human-readable string representation of the value.
+
+        Returns:
+            The string representation of the wrapped value.
+
+        Example:
+            ```python
+            class Price(ValueObject[float]):
+                pass
+
+            price = Price(29.99)
+            str(price)  # '29.99'
+            print(f"Product costs ${price}")  # Product costs $29.99
+            ```
+        """
+        return str(self._value)
+
+    @override
+    def __hash__(self) -> int:
+        """
+        Return the hash value of this value object.
+
+        The hash is based on the wrapped value, making value objects suitable
+        for use as dictionary keys or in sets.
+
+        Returns:
+            The hash value of the wrapped value.
+
+        Example:
+            ```python
+            class CategoryId(ValueObject[str]):
+                pass
+
+            cat1 = CategoryId("electronics")
+            cat2 = CategoryId("books")
+            cat3 = CategoryId("electronics")
+
+            categories = {cat1: "Electronics", cat2: "Books"}
+            categories[cat3]  # 'Electronics'
+
+            unique_categories = {cat1, cat2, cat3}
+            len(unique_categories)  # 2
+            ```
+        """
+        return hash(self._value)
+
+    @override
+    def __setattr__(self, name: str, value: T) -> None:
+        """
+        Prevent modification of the value after initialization.
+
+        This method enforces immutability by raising an AttributeError for any
+        attempt to modify the value or access non-existent attributes.
+
+        Args:
+            name: The name of the attribute being set.
+            value: The value being assigned to the attribute.
+
+        Raises:
+            AttributeError: Always raised to prevent modification of the value object.
+
+        Example:
+            ```python
+            class CustomerId(ValueObject[int]):
+                pass
+
+            customer = CustomerId(12345)
+            customer._value = 54321  # Raises AttributeError
+
+            customer.new_attribute = "test"  # Raises AttributeError
+            ```
+        """
+        if name in self.__slots__:
+            raise AttributeError("Cannot modify the value of a ValueObject")
+
+        public_name = name.replace("_", "")
+        public_slots = [slot.replace("_", "") for slot in self.__slots__]
+        if public_name in public_slots:
+            raise AttributeError("Cannot modify the value of a ValueObject")
+
+        raise AttributeError(f"Class {self.__class__.__name__} object has no attribute '{name}'")

sindripy-0.1.1.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.3
+Name: sindripy
+Version: 0.1.1
+Summary: Value Object and Object Mother patterns implementation for Python
+Author: dimanu-py
+Author-email: dimanu-py <dimanu.py@gmail.com>
+License: MIT License
+         
+         Copyright (c) 2025 dimanu-py
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+         
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Testing :: Unit
+Classifier: Topic :: Software Development :: Testing :: BDD
+Classifier: Framework :: FastAPI
+Requires-Python: >=3.10, <3.14
+Project-URL: documentation, https://dimanu-py.github.io/sindri/home/
+Project-URL: repository, https://github.com/dimanu-py/sindri/
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <h1>🛠️ Sindripy 🛠️</h1>
+  <strong>Easy use and customizable implementation for Value Object and Object Mother patterns.</strong>
+</div>
+
+<p align="center">
+  <a href="https://dimanu-py.github.io/sindri/home/getting_started/">Getting Started</a>&nbsp;&nbsp;•&nbsp;
+  <a href="https://dimanu-py.github.io/sindri/value_objects/">Value Object Pattern</a>&nbsp;&nbsp;•&nbsp;
+  <a href="https://dimanu-py.github.io/sindri/object_mothers/">Object Mother Pattern</a>&nbsp;&nbsp;•&nbsp;
+  <a href="https://dimanu-py.github.io/sindri/home/contributing/">Contributing</a>
+</p>
+
+> [!NOTE]
+> This project was generated using [Instant Python](https://github.com/dimanu-py/instant-python), a fast, easy and reliable project generator for Python projects.
+
+<div align="center"><table><tr><td>
+Sindri replaces ad hoc primitives and fragile validators with a consistent Value Object and Aggregate 
+toolkit you can adopt quickly. 
+Spin up validated value objects, aggregates, and test data with a simple and a small, focused API.
+
+Sindripy provides a basic-high-customizable implementation to help you enforce
+domain invariants and improve code quality with minimal effort.
+
+<br>
+
+<b>Why use sindripy?</b> Building your domain with Sindri lets you:
+
+<ul style="list-style-type: none">
+  <li>⏱️ Cut domain modeling and validation to seconds</li>
+  <li>🛡️ Declare immutable, validated value objects with clear error messages</li>
+  <li>🧩 Model aggregates with explicit invariants and composition</li>
+  <li>🧪 Generate realistic test data via the Object Mother pattern</li>
+  <li>🧰 Start from ready made primitives and identifiers or extend with your own</li>
+  <li>🔧 Plug in custom validators, decorators, and typed primitives</li>
+</ul>
+
+</td></tr></table></div>
+
+## Documentation
+
+This section provides a high-level overview of the `sindripy` library, its features, and how to get started.
+For detailed instructions and examples, please refer to the [full Sindripy documentation](https://dimanu-py.github.io/sindri/home/).
+
+- [Installation](#installation)
+- [Basic Usage](#basic-usage)
+- [Contributing](#contributing)
+
+### Need help?
+
+-   Join a discussion 💬 on [GitHub Discussions]
+-   [Raise an issue][GitHub Issues] on GitHub
+
+[GitHub Discussions]: https://github.com/dimanu-py/sindri/discussions
+[GitHub Issues]: https://github.com/dimanu-py/sindri/issues
+
+## Installation
+
+The latest version of `sindripy` can be installed from PyPI:
+
+```bash
+pip install sindripy
+```
+
+### Requirements
+
+Sindri tries to support the latest Python versions, we officially support from Python 3.10 to 3.13.
+Older versions of Python may work, but they are not guaranteed to be compatible.
+
+## Basic Usage
+
+Here is a simple example of how to use `sindri` to create a value object and generate test data using an object mother.
+
+```python
+from sindripy.value_objects import Integer, String
+
+age = Integer(30)
+name = String("John Doe")
+
+print(f"Name: {name.value}, Age: {age.value}")
+```
+
+```python
+from sindripy.mothers import IntegerPrimitivesMother, StringPrimitivesMother
+
+random_age = IntegerPrimitivesMother.any()
+random_name = StringPrimitivesMother.any()
+```
+
+> [!NOTE]
+> To learn more about advanced usage of value objects, including validation, custom value objects,
+> complex objects like aggregates, visit the [Value Objects](https://dimanu-py.github.io/sindri/value_objects/)
+> and [Object Mothers](https://dimanu-py.github.io/sindri/object_mothers) sections.
+
+## Contributing
+
+We welcome contributions to `sindripy`! If you have ideas, suggestions, or improvements, please check out our
+[contributing guide](https://dimanu-py.github.io/sindri/home/contributing/) for details on how to get involved.

sindripy-0.1.1.dist-info/RECORD

@@ -0,0 +1,34 @@
+sindripy/__init__.py,sha256=An0nQ4Kz96DYU-NZ5TgEJSQZ_Tmw98iAPCRqypn2OLk,330
+sindripy/_compat.py,sha256=_IWn8-egEjTmH30eWC4RK0uzQAwCirBhbNFegg1-iwo,334
+sindripy/mothers/__init__.py,sha256=OyZPL3XJzZQ5TiKNyGmBfFZhj176gjMlLrpYDErbD8M,1043
+sindripy/mothers/identifiers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sindripy/mothers/identifiers/string_uuid_primitives_mother.py,sha256=SCuBH1ZPn9tEwk3WcNFm_QoER3v-S6n4HgvfajDC-vI,459
+sindripy/mothers/object_mother.py,sha256=mKJh9ilL0G07icZUJ1JxfmJPzSKde0fcbWJ8wTLOwlk,194
+sindripy/mothers/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sindripy/mothers/primitives/boolean_primitives_mother.py,sha256=ioxVaW3qBbLC19l-ViNrzFRlI8fs1wpIELYZqWhobys,494
+sindripy/mothers/primitives/float_primitives_mother.py,sha256=K5BYdDCZe8jJOHHWKVc9L2dKllin6F-oijOhugyW2Pg,1056
+sindripy/mothers/primitives/integer_primitives_mother.py,sha256=j7pG2m0PgxatWTaDTyWwm2vN9zFEzB4XJknVReJOaVc,1174
+sindripy/mothers/primitives/list_primitives_mother.py,sha256=2tbjEjvYQmW3uSttShWiO0JZkv_zI0kse08dyhPdGy8,258
+sindripy/mothers/primitives/string_primitives_mother.py,sha256=a7KntLnnW6hd4i661DhP3VSLZEaSha6QBa2b5jjGesY,1689
+sindripy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sindripy/value_objects/__init__.py,sha256=ILNZWS74OkBOOavJWDx9QT7z8aIAzJ1usTE5coK-EBw,1038
+sindripy/value_objects/aggregate.py,sha256=oZaaX3ePAy0JwdcLWvbjl3EDAUkUF1P5lDyk_lDB8Sg,12516
+sindripy/value_objects/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sindripy/value_objects/decorators/validation.py,sha256=yDOtgOkdQmCFTGosVAj3P2aok5-FpNMWmGZc6PfnzNU,903
+sindripy/value_objects/errors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sindripy/value_objects/errors/incorrect_value_type_error.py,sha256=Wq9pLxfA4yfRm7hdyvIQSslKUZWxNABin0HPLhWfmXU,383
+sindripy/value_objects/errors/invalid_id_format_error.py,sha256=muQ2awpbz7hFXGJHa6GY9LK4p1SkN3fYPXj2LIgqB_g,265
+sindripy/value_objects/errors/required_value_error.py,sha256=ghTKxSZEXeVaGML7vuJCU41_6KySrBG5n1MS26EB8LU,267
+sindripy/value_objects/errors/sindri_validation_error.py,sha256=Nf9mpw67gpj0Gbofrzm2MNJyqhNb69uxokdtsa7CnXI,316
+sindripy/value_objects/identifiers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sindripy/value_objects/identifiers/string_uuid.py,sha256=rkMBhhIuuFInGeCKY1ZqK3vkx-WoPzZApFJ2TmZkA30,2058
+sindripy/value_objects/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sindripy/value_objects/primitives/boolean.py,sha256=iO3x6ThapXKdnw12dactFhtuG5yHhGlX2-P94C9YQc0,1537
+sindripy/value_objects/primitives/float.py,sha256=0C8mdqSD3HjeEqBH7Yq1dN0giJF-EuLw9hFhGUg3P7k,1564
+sindripy/value_objects/primitives/integer.py,sha256=sxvphjTuLfEHEQDiREhIipzscu8oDwNs3lpDalYL6w8,1500
+sindripy/value_objects/primitives/list.py,sha256=1i_wIRE1YVLNcc_EM3hKmNyPtx53iQX4k3KarKat450,9565
+sindripy/value_objects/primitives/string.py,sha256=AVqYagNp634hHyT-L_DMxcnVjseYyfB5sZ8DUjY9Xhw,1510
+sindripy/value_objects/value_object.py,sha256=cMUovcKjRIUcqs5hOHErlhRCLfSTs7sf9NeINR3JORQ,8167
+sindripy-0.1.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+sindripy-0.1.1.dist-info/METADATA,sha256=ds0DPVuoIDZOtxcqv6JuaRZ19I7ri4KpRX3jhS8Vrwo,6093
+sindripy-0.1.1.dist-info/RECORD,,

sindripy-0.1.1.dist-info/WHEEL

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