conformly 0.7.4__tar.gz → 0.8.0__tar.gz

conformly-0.8.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: conformly
+Version: 0.8.0
+Summary: Generate valid & invalid test data from your typed schemas
+Author-email: Nikita Shabanov <nik.shabanov2024@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nashabanov/conformly
+Project-URL: Repository, https://github.com/nashabanov/conformly.git
+Project-URL: Issues, https://github.com/nashabanov/conformly/issues
+Keywords: testing,fixtures,test-data,dataclasses,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rstr>=3.2.2
+Provides-Extra: pydantic
+Requires-Dist: pydantic<3.0.0,>=2.0.0; extra == "pydantic"
+Requires-Dist: email-validator>=2.0.0; extra == "pydantic"
+Provides-Extra: attrs
+Requires-Dist: attrs>=23.0.0; extra == "attrs"
+Provides-Extra: all
+Requires-Dist: pydantic<3.0.0,>=2.0.0; extra == "all"
+Requires-Dist: email-validator>=2.0.0; extra == "all"
+Requires-Dist: attrs>=23.0.0; extra == "all"
+Dynamic: license-file
+
+# conformly
+
+[![CI](https://github.com/nashabanov/conformly/actions/workflows/ci.yaml/badge.svg)](https://github.com/nashabanov/conformly/actions/workflows/ci.yaml)
+[![codecov](https://codecov.io/github/nashabanov/conformly/graph/badge.svg?branch=main)](https://codecov.io/github/nashabanov/conformly)
+[![PyPI](https://img.shields.io/pypi/v/conformly.svg)](https://pypi.org/project/conformly/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/conformly.svg)](https://pypi.org/project/conformly/)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Status: Beta](https://img.shields.io/badge/status-beta-orange?style=flat-square)](https://github.com/nashabanov/conformly/releases)
+[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+**Declarative test data generator for Python.**
+
+Define constraints once in type annotations — generate both valid and minimal invalid test data automatically.
+No factories, no hardcoded fixtures, no drift when schema changes.
+
+Conformly turns typed schemas into dictionaries for fixtures and validation tests.
+Use the same schema for happy-path payloads and targeted negative cases.
+
+## Key capabilities
+
+- **Constraint-driven generation** from type annotations and model metadata.
+- **Minimal invalid cases** targeting one field and a selected violation.
+- **Schema as the single source of truth** for test data.
+- Dataclasses and TypedDicts, with optional Pydantic and attrs integrations.
+- Nested models, collections, reproducible seeds, and field overrides.
+
+## Installation
+
+Requires Python 3.12 or newer.
+
+```bash
+pip install conformly
+# Optional integrations:
+pip install 'conformly[pydantic]'
+pip install 'conformly[attrs]'
+```
+
+## Quickstart
+
+```python
+from dataclasses import dataclass
+from typing import Annotated
+
+from conformly import GreaterOrEqual, MaxLength, MinLength, V, case, path
+
+
+@dataclass
+class CreateUser:
+    username: Annotated[str, MinLength(3), MaxLength(32)]
+    age: Annotated[int, GreaterOrEqual(18)]
+
+
+payload = case(CreateUser)
+assert 3 <= len(payload["username"]) <= 32
+assert payload["age"] >= 18
+
+invalid = case(
+    CreateUser, valid=False, strategy=path("age").violate(V.BELOW_MIN)
+)
+assert invalid["age"] < 18
+assert 3 <= len(invalid["username"]) <= 32
+```
+
+Results are dictionaries, not model instances. Invalid generation targets one
+field; only the selected violation is guaranteed on that target. Defaults and
+overrides are trusted rather than validated. See the
+[invalid generation contract](https://github.com/nashabanov/conformly/blob/main/docs/strategies.md#invalid-generation-contract).
+
+## Documentation and examples
+
+Start with [Getting started](https://github.com/nashabanov/conformly/blob/main/docs/getting-started.md), browse the
+[documentation index](https://github.com/nashabanov/conformly/blob/main/docs/README.md), or run the [examples](https://github.com/nashabanov/conformly/blob/main/examples/README.md).
+The [API reference](https://github.com/nashabanov/conformly/blob/main/docs/api-reference.md) lists parameters and defaults.
+
+## Development and contributing
+
+See [CONTRIBUTING.md](https://github.com/nashabanov/conformly/blob/main/CONTRIBUTING.md) for setup and checks, and
+[CHANGELOG.md](https://github.com/nashabanov/conformly/blob/main/CHANGELOG.md) for release notes and migration guidance.
+
+## License
+
+MIT — see [LICENSE](https://github.com/nashabanov/conformly/blob/main/LICENSE).

conformly-0.8.0/README.md

@@ -0,0 +1,84 @@
+# conformly
+
+[![CI](https://github.com/nashabanov/conformly/actions/workflows/ci.yaml/badge.svg)](https://github.com/nashabanov/conformly/actions/workflows/ci.yaml)
+[![codecov](https://codecov.io/github/nashabanov/conformly/graph/badge.svg?branch=main)](https://codecov.io/github/nashabanov/conformly)
+[![PyPI](https://img.shields.io/pypi/v/conformly.svg)](https://pypi.org/project/conformly/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/conformly.svg)](https://pypi.org/project/conformly/)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Status: Beta](https://img.shields.io/badge/status-beta-orange?style=flat-square)](https://github.com/nashabanov/conformly/releases)
+[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+**Declarative test data generator for Python.**
+
+Define constraints once in type annotations — generate both valid and minimal invalid test data automatically.
+No factories, no hardcoded fixtures, no drift when schema changes.
+
+Conformly turns typed schemas into dictionaries for fixtures and validation tests.
+Use the same schema for happy-path payloads and targeted negative cases.
+
+## Key capabilities
+
+- **Constraint-driven generation** from type annotations and model metadata.
+- **Minimal invalid cases** targeting one field and a selected violation.
+- **Schema as the single source of truth** for test data.
+- Dataclasses and TypedDicts, with optional Pydantic and attrs integrations.
+- Nested models, collections, reproducible seeds, and field overrides.
+
+## Installation
+
+Requires Python 3.12 or newer.
+
+```bash
+pip install conformly
+# Optional integrations:
+pip install 'conformly[pydantic]'
+pip install 'conformly[attrs]'
+```
+
+## Quickstart
+
+```python
+from dataclasses import dataclass
+from typing import Annotated
+
+from conformly import GreaterOrEqual, MaxLength, MinLength, V, case, path
+
+
+@dataclass
+class CreateUser:
+    username: Annotated[str, MinLength(3), MaxLength(32)]
+    age: Annotated[int, GreaterOrEqual(18)]
+
+
+payload = case(CreateUser)
+assert 3 <= len(payload["username"]) <= 32
+assert payload["age"] >= 18
+
+invalid = case(
+    CreateUser, valid=False, strategy=path("age").violate(V.BELOW_MIN)
+)
+assert invalid["age"] < 18
+assert 3 <= len(invalid["username"]) <= 32
+```
+
+Results are dictionaries, not model instances. Invalid generation targets one
+field; only the selected violation is guaranteed on that target. Defaults and
+overrides are trusted rather than validated. See the
+[invalid generation contract](https://github.com/nashabanov/conformly/blob/main/docs/strategies.md#invalid-generation-contract).
+
+## Documentation and examples
+
+Start with [Getting started](https://github.com/nashabanov/conformly/blob/main/docs/getting-started.md), browse the
+[documentation index](https://github.com/nashabanov/conformly/blob/main/docs/README.md), or run the [examples](https://github.com/nashabanov/conformly/blob/main/examples/README.md).
+The [API reference](https://github.com/nashabanov/conformly/blob/main/docs/api-reference.md) lists parameters and defaults.
+
+## Development and contributing
+
+See [CONTRIBUTING.md](https://github.com/nashabanov/conformly/blob/main/CONTRIBUTING.md) for setup and checks, and
+[CHANGELOG.md](https://github.com/nashabanov/conformly/blob/main/CHANGELOG.md) for release notes and migration guidance.
+
+## License
+
+MIT — see [LICENSE](https://github.com/nashabanov/conformly/blob/main/LICENSE).

{conformly-0.7.4 → conformly-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "conformly"
-version = "0.7.4"
+version = "0.8.0"
 description = "Generate valid & invalid test data from your typed schemas"
 readme = "README.md"
 requires-python = ">=3.12"

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/__init__.py

@@ -18,7 +18,7 @@ from ._internal.constraints import (
     Pattern,
     UniqueItems,
 )
-from ._internal.fields import Email, IPv4, IPv6, IPvAny
+from ._internal.fields import Email, HttpUrl, IPv4, IPv6, IPvAny, Url
 from ._internal.types import ViolationType as V
 from .exceptions import ConformlyError
 
@@ -27,6 +27,7 @@ __all__ = [
     "Email",
     "GreaterOrEqual",
     "GreaterThan",
+    "HttpUrl",
     "IPv4",
     "IPv6",
     "IPvAny",
@@ -40,6 +41,7 @@ __all__ = [
     "OneOf",
     "Pattern",
     "UniqueItems",
+    "Url",
     "V",
     "case",
     "cases",

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/constraints/numeric.py

@@ -1,13 +1,15 @@
 from dataclasses import dataclass
+from datetime import date, datetime, time, timedelta
 
 from .base import Constraint
 
 TNum = int | float
+TBound = TNum | datetime | date | time | timedelta
 
 
 @dataclass(frozen=True, slots=True)
 class GreaterThan(Constraint):
-    value: TNum
+    value: TBound
 
     def __repr__(self) -> str:
         return f"GreaterThan(value={self.value})"
@@ -15,7 +17,7 @@ class GreaterThan(Constraint):
 
 @dataclass(frozen=True, slots=True)
 class GreaterOrEqual(Constraint):
-    value: TNum
+    value: TBound
 
     def __repr__(self) -> str:
         return f"GreaterOrEqual(value={self.value})"
@@ -23,7 +25,7 @@ class GreaterOrEqual(Constraint):
 
 @dataclass(frozen=True, slots=True)
 class LessThan(Constraint):
-    value: TNum
+    value: TBound
 
     def __repr__(self) -> str:
         return f"LessThan(value={self.value})"
@@ -31,7 +33,7 @@ class LessThan(Constraint):
 
 @dataclass(frozen=True, slots=True)
 class LessOrEqual(Constraint):
-    value: TNum
+    value: TBound
 
     def __repr__(self) -> str:
         return f"LessOrEqual(value={self.value})"

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/fields/__init__.py

@@ -4,7 +4,7 @@ from .registry import (
     SPECIAL_STRINGS,
     SPECIAL_TYPE_TO_KIND,
 )
-from .special_types import Email, IPv4, IPv6, IPvAny, SpecialString
+from .special_types import Email, HttpUrl, IPv4, IPv6, IPvAny, SpecialString, Url
 
 __all__ = [
     "SPECIAL_KINDS",
@@ -12,8 +12,10 @@ __all__ = [
     "SPECIAL_STRINGS",
     "SPECIAL_TYPE_TO_KIND",
     "Email",
+    "HttpUrl",
     "IPv4",
     "IPv6",
     "IPvAny",
     "SpecialString",
+    "Url",
 ]

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/generator/registry.py

@@ -2,6 +2,7 @@ from ._errors import generation_error
 from .protocol import TypeGeneratorProtocol
 from .types import (
     boolean,
+    bytes,
     dictionaries,
     email,
     enum,
@@ -12,6 +13,7 @@ from .types import (
     ipvany,
     list,
     string,
+    temporal,
     tuple,
     url,
     uuid,
@@ -21,6 +23,7 @@ from conformly._internal.types import FieldKind
 
 _GENERATORS: dict[FieldKind, TypeGeneratorProtocol] = {
     FieldKind.STRING: string,
+    FieldKind.BYTES: bytes,
     FieldKind.BOOLEAN: boolean,
     FieldKind.FLOAT: float,
     FieldKind.INTEGER: integer,
@@ -33,12 +36,17 @@ _GENERATORS: dict[FieldKind, TypeGeneratorProtocol] = {
     FieldKind.DICT: dictionaries,
     FieldKind.TUPLE: tuple,
     FieldKind.UUID: uuid,
+    FieldKind.DATETIME: temporal,
+    FieldKind.DATE: temporal,
+    FieldKind.TIME: temporal,
+    FieldKind.TIMEDELTA: temporal,
     FieldKind.URL: url,
     FieldKind.HTTPURL: url,
 }
 
 _MISMATCH_MAPPING: dict[FieldKind, FieldKind] = {
     FieldKind.STRING: FieldKind.INTEGER,
+    FieldKind.BYTES: FieldKind.INTEGER,
     FieldKind.BOOLEAN: FieldKind.STRING,
     FieldKind.INTEGER: FieldKind.STRING,
     FieldKind.FLOAT: FieldKind.STRING,
@@ -51,6 +59,10 @@ _MISMATCH_MAPPING: dict[FieldKind, FieldKind] = {
     FieldKind.LIST: FieldKind.INTEGER,
     FieldKind.DICT: FieldKind.STRING,
     FieldKind.UUID: FieldKind.FLOAT,
+    FieldKind.DATETIME: FieldKind.STRING,
+    FieldKind.DATE: FieldKind.STRING,
+    FieldKind.TIME: FieldKind.STRING,
+    FieldKind.TIMEDELTA: FieldKind.STRING,
     FieldKind.URL: FieldKind.FLOAT,
     FieldKind.HTTPURL: FieldKind.INTEGER,
     FieldKind.TUPLE: FieldKind.INTEGER,

conformly-0.8.0/src/conformly/_internal/generator/types/bytes.py

@@ -0,0 +1,25 @@
+from .._errors import generation_error
+from ..context import GenerationContext
+
+from conformly._internal.resolver.semantics import BytesSemantic
+from conformly._internal.types import ViolationType
+
+
+def generate_value(
+    ctx: GenerationContext, semantic: BytesSemantic, violation: ViolationType | None
+) -> bytes:
+    lower = semantic.length_range.min_length
+    upper = semantic.length_range.max_length
+    if violation is None:
+        length = ctx.rng.randint(lower, upper if upper is not None else lower + 50)
+    elif violation == ViolationType.TOO_SHORT and lower > 0:
+        length = lower - 1
+    elif violation == ViolationType.TOO_LONG and upper is not None:
+        length = upper + 1
+    else:
+        raise generation_error(
+            "Unsupported bytes violation",
+            code="unsupported_violation",
+            violation=violation.value,
+        )
+    return ctx.rng.randbytes(length)

conformly-0.8.0/src/conformly/_internal/generator/types/temporal.py

@@ -0,0 +1,59 @@
+from datetime import UTC, date, datetime, time, timedelta
+
+from .._errors import generation_error
+from ..context import GenerationContext
+
+from conformly._internal.resolver.semantics import TemporalSemantic
+from conformly._internal.resolver.semantics.temporal import MICROSECONDS_PER_DAY
+from conformly._internal.types import FieldKind, ViolationType
+
+
+def generate_value(
+    ctx: GenerationContext, semantic: TemporalSemantic, violation: ViolationType | None
+) -> date | time | timedelta:
+    if violation is None:
+        tick = ctx.rng.randint(semantic.min_value, semantic.max_value)
+    elif (
+        violation == ViolationType.BELOW_MIN
+        and semantic.min_value > semantic.domain_min
+    ):
+        tick = semantic.min_value - 1
+    elif (
+        violation == ViolationType.ABOVE_MAX
+        and semantic.max_value < semantic.domain_max
+    ):
+        tick = semantic.max_value + 1
+    else:
+        raise generation_error(
+            "No representable temporal violation available",
+            code="unsupported_temporal_violation",
+            violation=violation.value,
+        )
+
+    match semantic.kind:
+        case FieldKind.DATE:
+            return date.fromordinal(tick)
+        case FieldKind.TIME:
+            return _time_from_tick(tick)
+        case FieldKind.DATETIME:
+            day, remainder = divmod(tick, MICROSECONDS_PER_DAY)
+            return datetime.combine(
+                date.fromordinal(day + 1),
+                _time_from_tick(remainder),
+                tzinfo=UTC if semantic.aware else None,
+            )
+        case FieldKind.TIMEDELTA:
+            return timedelta(microseconds=tick)
+        case _:
+            raise generation_error(
+                "Unsupported temporal kind",
+                code="unsupported_temporal_kind",
+                kind=semantic.kind.value,
+            )
+
+
+def _time_from_tick(tick: int) -> time:
+    seconds, microsecond = divmod(tick, 1_000_000)
+    hour, seconds = divmod(seconds, 3600)
+    minute, second = divmod(seconds, 60)
+    return time(hour, minute, second, microsecond)

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/parser/extractors/constraints.py

@@ -1,4 +1,5 @@
 from collections.abc import Mapping
+from datetime import date, datetime, time, timedelta
 from typing import Annotated, Any, cast, get_args, get_origin
 
 from conformly._internal.constraints import (
@@ -121,6 +122,11 @@ def _coerce_constraint_value(k: ConstraintType, v: Any) -> Any:
             },
         )
 
+    if k in ("gt", "ge", "lt", "le") and isinstance(
+        v, (date, datetime, time, timedelta)
+    ):
+        return v
+
     if k in NUMERIC_CONSTRAINTS:
         if isinstance(v, (int, float)) and not isinstance(v, bool):
             return v

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/planner/field.py

@@ -7,12 +7,14 @@ from conformly._internal.fields import SPECIAL_KINDS
 from conformly._internal.resolver import ResolvedModel
 from conformly._internal.resolver.semantics import (
     BooleanSemantic,
+    BytesSemantic,
     EnumSemantic,
     FieldSemantics,
     ListSemantic,
     NumericSemantic,
     ObjectSemantic,
     StringSemantic,
+    TemporalSemantic,
     TupleSemantic,
     UUIDSemantic,
 )
@@ -131,6 +133,13 @@ def _define_allowed_violation_types(
         case StringSemantic(kind=kind) if kind in SPECIAL_KINDS | {FieldKind.STRING}:
             violations = _define_string_violations(semantic)
 
+        case BytesSemantic():
+            violations = []
+            if semantic.length_range.min_length > 0:
+                violations.append(ViolationType.TOO_SHORT)
+            if semantic.length_range.max_length is not None:
+                violations.append(ViolationType.TOO_LONG)
+
         case NumericSemantic(kind=(FieldKind.INTEGER | FieldKind.FLOAT)):
             violations = _define_numeric_violations(semantic)
 
@@ -152,6 +161,13 @@ def _define_allowed_violation_types(
                 ViolationType.WRONG_UUID_CHARACTER,
             ]
 
+        case TemporalSemantic():
+            violations = []
+            if semantic.min_value > semantic.domain_min:
+                violations.append(ViolationType.BELOW_MIN)
+            if semantic.max_value < semantic.domain_max:
+                violations.append(ViolationType.ABOVE_MAX)
+
         case (
             ObjectSemantic(kind=FieldKind.OBJECT)
             | BooleanSemantic(kind=FieldKind.BOOLEAN)

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/resolver/resolve.py

@@ -17,6 +17,8 @@ from .semantics import (
     TupleSemantic,
     UUIDSemantic,
 )
+from .semantics.bytes import create_bytes_semantic
+from .semantics.temporal import TEMPORAL_TYPES, create_temporal_semantic
 
 from conformly._internal.constraints import (
     Constraint,
@@ -221,6 +223,10 @@ def create_scalar_semantic(
 
         return create_string_semantic(c, kind)
 
+    for kind, temporal_type in TEMPORAL_TYPES.items():
+        if t is temporal_type:
+            return create_temporal_semantic(kind, c)
+
     if t is uuid.UUID:
         return UUIDSemantic(has_constraints=True)
 
@@ -236,6 +242,9 @@ def create_scalar_semantic(
             multiple_of=_extract_numeric_multiple_of(c),
         )
 
+    elif t is bytes:
+        return create_bytes_semantic(c)
+
     elif t is str:
         return create_string_semantic(c)
 
@@ -351,6 +360,11 @@ def _calculate_int_bounds(constraints: tuple[Constraint, ...]) -> Range:
             )
 
         v = c.value
+        if not isinstance(v, (int, float)):
+            raise SchemaError(
+                "Numeric bounds require numeric values",
+                context={"code": "invalid_numeric_bound_type"},
+            )
 
         match c:
             case GreaterThan():
@@ -382,6 +396,11 @@ def _calculate_float_bounds(constraints: tuple[Constraint, ...]) -> Range:
         if not isinstance(c, (GreaterThan, GreaterOrEqual, LessThan, LessOrEqual)):
             continue
 
+        if not isinstance(c.value, (int, float)):
+            raise SchemaError(
+                "Numeric bounds require numeric values",
+                context={"code": "invalid_numeric_bound_type"},
+            )
         v = float(c.value)
         if math.isnan(v):
             raise SchemaError(
@@ -552,7 +571,7 @@ def create_list_semantics(
         element_nested_model=element_nested_model,
         length_range=length_range,
         is_unique_items=is_unique_items,
-        has_constraints=has_constraints,
+        has_constraints=has_constraints or element_semantic.has_constraints,
     )
 
 
@@ -601,7 +620,11 @@ def create_dict_semantic(
         value_nested_model=value_nested_model,
         length_range=length_range,
         is_unique_items=False,
-        has_constraints=has_constraints,
+        has_constraints=(
+            has_constraints
+            or key_semantic.has_constraints
+            or value_semantic.has_constraints
+        ),
     )
 
 

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/resolver/semantics/__init__.py

@@ -1,28 +1,33 @@
 from .boolean import BooleanSemantic
+from .bytes import BytesSemantic
 from .dict import DictSemantic
 from .enum import EnumSemantic
 from .list import ListSemantic
 from .numeric import NumericSemantic
 from .object import ObjectSemantic
 from .string import StringSemantic
+from .temporal import TemporalSemantic
 from .tuple import TupleSemantic
 from .uuid import UUIDSemantic
 
 FieldSemantics = (
     NumericSemantic
     | StringSemantic
+    | BytesSemantic
     | ObjectSemantic
     | BooleanSemantic
     | EnumSemantic
     | ListSemantic
     | UUIDSemantic
     | DictSemantic
+    | TemporalSemantic
     | TupleSemantic
 )
 
 
 __all__ = [
     "BooleanSemantic",
+    "BytesSemantic",
     "DictSemantic",
     "EnumSemantic",
     "FieldSemantics",
@@ -30,6 +35,7 @@ __all__ = [
     "NumericSemantic",
     "ObjectSemantic",
     "StringSemantic",
+    "TemporalSemantic",
     "TupleSemantic",
     "UUIDSemantic",
 ]

{conformly-0.7.4 → conformly-0.8.0}/src/conformly/_internal/resolver/semantics/_domains.py

@@ -2,11 +2,17 @@ from typing import Any
 
 from . import BooleanSemantic, EnumSemantic, FieldSemantics, NumericSemantic
 from ._numeric import integer_multiple_step
+from .bytes import BytesSemantic
+from .temporal import TemporalSemantic
 
 from conformly._internal.types import FieldKind
 
 
 def finite_cardinality(semantic: FieldSemantics) -> int | None:
+    if isinstance(semantic, BytesSemantic) and semantic.length_range.max_length == 0:
+        return 1
+    if isinstance(semantic, TemporalSemantic):
+        return semantic.max_value - semantic.min_value + 1
     if isinstance(semantic, BooleanSemantic):
         return 2
     if isinstance(semantic, EnumSemantic):

conformly-0.8.0/src/conformly/_internal/resolver/semantics/bytes.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+
+from .base import BaseSemantic
+
+from conformly._internal.constraints import Constraint, MaxLength, MinLength
+from conformly._internal.types import FieldKind, LengthRange
+from conformly.exceptions import SchemaError
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class BytesSemantic(BaseSemantic):
+    length_range: LengthRange
+
+    @property
+    def kind(self) -> FieldKind:
+        return FieldKind.BYTES
+
+
+def create_bytes_semantic(constraints: tuple[Constraint, ...]) -> BytesSemantic:
+    lower = 0
+    upper: int | None = None
+    for constraint in constraints:
+        if not isinstance(constraint, (MinLength, MaxLength)):
+            raise SchemaError(
+                "Bytes fields only support MinLength and MaxLength",
+                context={
+                    "code": "unsupported_bytes_constraint",
+                    "constraint": type(constraint).__name__,
+                },
+            )
+        value = constraint.value
+        if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+            raise SchemaError(
+                "Bytes length must be a non-negative integer",
+                context={"code": "invalid_bytes_length", "value": value},
+            )
+        if isinstance(constraint, MinLength):
+            lower = max(lower, value)
+        else:
+            upper = value if upper is None else min(upper, value)
+    if upper is not None and lower > upper:
+        raise SchemaError(
+            "Invalid bytes length range",
+            context={"code": "invalid_length_range", "min": lower, "max": upper},
+        )
+    return BytesSemantic(
+        length_range=LengthRange(lower, upper), has_constraints=bool(constraints)
+    )