conformly 0.7.1__tar.gz → 0.7.2__tar.gz

{conformly-0.7.1/src/conformly.egg-info → conformly-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conformly
-Version: 0.7.1
+Version: 0.7.2
 Summary: Generate valid & invalid test data from your typed schemas
 Author-email: Nikita Shabanov <nik.shabanov2024@gmail.com>
 License: MIT
@@ -561,6 +561,24 @@ case(Model)
 
 This ensures consistent output format (list) while preserving uniqueness guarantees.
 
+### Tuple support
+
+Fixed tuples and variadic tuples (`tuple[T, ...]`) are generated in their declared
+order. Element annotations and nested models are handled independently:
+
+```python
+@dataclass
+class Event:
+    point: tuple[float, float]
+    labels: tuple[str, ...]
+
+case(Event, valid=True)
+# -> {"point": (1.2, 3.4), "labels": ("abc", "def")}
+```
+
+For invalid generation, a constrained tuple element is selected and invalidated
+without changing the other elements.
+
 ### Dict support
 
 `conformly` supports generation of `dict[K, V]`, where K must be a hashable type (`str` or `Enum`) and `V` can be any supported type (primitives, nested models, etc.).
@@ -621,7 +639,7 @@ from conformly.tracer import Tracer
 
 tracer = Tracer()
 
-payload = case(User, valid=True, tracer=tracer)
+payload = case(User, valid=False, tracer=tracer)
 
 trace = tracer.build()
 

{conformly-0.7.1 → conformly-0.7.2}/README.md

@@ -528,6 +528,24 @@ case(Model)
 
 This ensures consistent output format (list) while preserving uniqueness guarantees.
 
+### Tuple support
+
+Fixed tuples and variadic tuples (`tuple[T, ...]`) are generated in their declared
+order. Element annotations and nested models are handled independently:
+
+```python
+@dataclass
+class Event:
+    point: tuple[float, float]
+    labels: tuple[str, ...]
+
+case(Event, valid=True)
+# -> {"point": (1.2, 3.4), "labels": ("abc", "def")}
+```
+
+For invalid generation, a constrained tuple element is selected and invalidated
+without changing the other elements.
+
 ### Dict support
 
 `conformly` supports generation of `dict[K, V]`, where K must be a hashable type (`str` or `Enum`) and `V` can be any supported type (primitives, nested models, etc.).
@@ -588,7 +606,7 @@ from conformly.tracer import Tracer
 
 tracer = Tracer()
 
-payload = case(User, valid=True, tracer=tracer)
+payload = case(User, valid=False, tracer=tracer)
 
 trace = tracer.build()
 

{conformly-0.7.1 → conformly-0.7.2}/pyproject.toml

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

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/generator/orchestration.py

@@ -10,7 +10,7 @@ from conformly._internal.resolver import (
     ResolvedModel,
     create_minimal_semantic,
 )
-from conformly._internal.resolver.semantics import ListSemantic
+from conformly._internal.resolver.semantics import ListSemantic, TupleSemantic
 from conformly._internal.tracer import Tracer, ValueSource
 from conformly._internal.types import UNSET, FieldKind, FieldPath, ViolationType
 
@@ -154,7 +154,9 @@ def generate_field(
 
             return default
 
-        if field.nested_model and not isinstance(field.semantic, ListSemantic):
+        if field.nested_model and not isinstance(
+            field.semantic, (ListSemantic, TupleSemantic)
+        ):
             return generate_valid(ctx, field.nested_model, overrides)
 
     violation = _choose_violation(violations)

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/generator/registry.py

@@ -12,6 +12,7 @@ from .types import (
     ipvany,
     list,
     string,
+    tuple,
     url,
     uuid,
 )
@@ -30,6 +31,7 @@ _GENERATORS: dict[FieldKind, TypeGeneratorProtocol] = {
     FieldKind.IPvAny: ipvany,
     FieldKind.LIST: list,
     FieldKind.DICT: dictionaries,
+    FieldKind.TUPLE: tuple,
     FieldKind.UUID: uuid,
     FieldKind.URL: url,
     FieldKind.HTTPURL: url,
@@ -51,6 +53,7 @@ _MISMATCH_MAPPING: dict[FieldKind, FieldKind] = {
     FieldKind.UUID: FieldKind.FLOAT,
     FieldKind.URL: FieldKind.FLOAT,
     FieldKind.HTTPURL: FieldKind.INTEGER,
+    FieldKind.TUPLE: FieldKind.INTEGER,
 }
 
 

conformly-0.7.2/src/conformly/_internal/generator/types/tuple.py

@@ -0,0 +1,93 @@
+from typing import Any
+
+from ..context import GenerationContext
+from ._utils import generate_collection_item
+
+from conformly._internal.resolver.semantics import TupleSemantic
+from conformly._internal.types import ViolationType
+from conformly.exceptions import PlanningError
+
+
+def _supports_violation(semantic: Any, violation: ViolationType) -> bool:
+    from conformly._internal.planner.field import _define_allowed_violation_types
+
+    try:
+        return violation in _define_allowed_violation_types(semantic)
+    except PlanningError:
+        return False
+
+
+def generate_value(
+    ctx: GenerationContext,
+    semantic: TupleSemantic,
+    violation: ViolationType | None = None,
+) -> tuple[Any, ...]:
+    if violation is None:
+        return _generate_valid_tuple(ctx, semantic)
+
+    return _generate_invalid_tuple(ctx, semantic, violation)
+
+
+def _generate_valid_tuple(
+    ctx: GenerationContext, semantic: TupleSemantic
+) -> tuple[Any, ...]:
+    if not semantic.is_variadic:
+        elements = semantic.elements_semantics
+    else:
+        min_len = semantic.length_range.min_length if semantic.length_range else 1
+        max_len = semantic.length_range.max_length if semantic.length_range else 3
+        length = ctx.rng.randint(min_len or 1, max_len or 3)
+        elements = semantic.elements_semantics * length
+
+    return tuple(
+        generate_collection_item(ctx, item_semantic, nested_model, None)
+        for item_semantic, nested_model in elements
+    )
+
+
+def _generate_invalid_tuple(
+    ctx: GenerationContext, semantic: TupleSemantic, violation: ViolationType
+) -> tuple[Any, ...]:
+    if violation in (ViolationType.TOO_LESS_ITEMS, ViolationType.TOO_MANY_ITEMS):
+        if not semantic.is_variadic:
+            return _generate_valid_tuple(ctx, semantic)
+
+        min_len = semantic.length_range.min_length if semantic.length_range else 1
+        max_len = semantic.length_range.max_length if semantic.length_range else 3
+        length = (
+            max(0, min_len - 1)
+            if violation == ViolationType.TOO_LESS_ITEMS
+            else (max_len or 3) + 1
+        )
+        return tuple(
+            generate_collection_item(ctx, *semantic.elements_semantics[0], None)
+            for _ in range(length)
+        )
+
+    if semantic.is_variadic:
+        min_len = semantic.length_range.min_length if semantic.length_range else 1
+        max_len = semantic.length_range.max_length if semantic.length_range else 3
+        length = ctx.rng.randint(min_len or 1, max_len or 3)
+        elements = semantic.elements_semantics * length
+    else:
+        elements = semantic.elements_semantics
+
+    candidates = [
+        i
+        for i, (item_semantic, _) in enumerate(elements)
+        if _supports_violation(item_semantic, violation)
+    ]
+    violate_idx = (
+        ctx.rng.choice(candidates)
+        if candidates
+        else ctx.rng.randint(0, len(elements) - 1)
+    )
+    return tuple(
+        generate_collection_item(
+            ctx,
+            item_semantic,
+            nested_model,
+            (violation,) if i == violate_idx else None,
+        )
+        for i, (item_semantic, nested_model) in enumerate(elements)
+    )

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/parser/core/field.py

@@ -2,7 +2,14 @@ from collections.abc import Callable
 from typing import Any
 
 from ..extractors.constraints import split_collection_constraints
-from ..extractors.types import DictNode, ListNode, ScalarNode, TypeNode, normalize_type
+from ..extractors.types import (
+    DictNode,
+    ListNode,
+    ScalarNode,
+    TupleNode,
+    TypeNode,
+    normalize_type,
+)
 from ..models import ElementSpec, FieldSpec
 
 from conformly._internal.constraints import Constraint
@@ -41,6 +48,22 @@ def build_field_spec(
                 nullable=node.nullable,
             )
 
+        case TupleNode():
+            element_constraints, collection_constraints = split_collection_constraints(
+                external_constraints
+            )
+
+            return FieldSpec(
+                name=name,
+                collection_type=node.origin,
+                collection_constraints=(*node.constraints, *collection_constraints),
+                items=tuple(
+                    resolve_element(i, name, element_constraints) for i in node.items
+                ),
+                default=default,
+                nullable=node.nullable,
+            )
+
         case DictNode():
             return FieldSpec(
                 name=name,

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/parser/extractors/types.py

@@ -37,6 +37,16 @@ class ListNode:
     item: "TypeNode"
 
 
+@dataclass(frozen=True, slots=True)
+class TupleNode:
+    kind: Literal["tuple"]
+    runtime_type: Any
+    origin: type
+    nullable: bool
+    constraints: tuple[Constraint, ...]
+    items: tuple["TypeNode", ...]
+
+
 @dataclass(frozen=True, slots=True)
 class DictNode:
     kind: Literal["dict"]
@@ -47,7 +57,7 @@ class DictNode:
     value: "TypeNode"
 
 
-TypeNode = ScalarNode | ListNode | DictNode
+TypeNode = ScalarNode | ListNode | DictNode | TupleNode
 
 
 def normalize_type(field_type: Any, field_name: str) -> TypeNode:
@@ -116,6 +126,32 @@ def _build_node(
             item=item,
         )
 
+    if origin is tuple:
+        if not args:
+            raise SchemaError(
+                f"Field '{field_name}': '{origin.__name__}' must be parameterized",
+                context={
+                    "code": "empty_collection",
+                    "field_name": field_name,
+                    "field_type": repr(t),
+                },
+            )
+        items: list[TypeNode] = []
+        if len(args) == 2 and args[1] is Ellipsis:
+            items.append(normalize_type(args[0], field_name))
+        else:
+            for i, _ in enumerate(args):
+                item = normalize_type(args[i], field_name)
+                items.append(item)
+        return TupleNode(
+            kind="tuple",
+            runtime_type=origin,
+            origin=origin,
+            nullable=nullable,
+            constraints=constraints,
+            items=tuple(items),
+        )
+
     if origin is dict:
         if len(args) != 2:
             raise SchemaError(

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/parser/models.py

@@ -23,6 +23,7 @@ class FieldSpec:
     collection_type: type | None = None
     collection_constraints: tuple[Constraint, ...] = ()
     item: ElementSpec | None = None
+    items: tuple[ElementSpec, ...] | None = None
     key: ElementSpec | None = None
     value: ElementSpec | None = None
     nullable: bool = False
@@ -38,6 +39,7 @@ class FieldSpec:
         return (
             (self.element is not None and len(self.element.constraints) != 0)
             or (self.item is not None and len(self.item.constraints) != 0)
+            or any(len(item.constraints) != 0 for item in (self.items or ()))
             or (self.key is not None and len(self.key.constraints) != 0)
             or (self.value is not None and len(self.value.constraints) != 0)
             or len(self.collection_constraints) != 0
@@ -47,6 +49,7 @@ class FieldSpec:
         return (
             (self.element is not None and self.element.nested_model is not None)
             or (self.item is not None and self.item.nested_model is not None)
+            or any(item.nested_model is not None for item in (self.items or ()))
             or (self.key is not None and self.key.nested_model is not None)
             or (self.value is not None and self.value.nested_model is not None)
         )

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/planner/field.py

@@ -11,6 +11,7 @@ from conformly._internal.resolver.semantics import (
     NumericSemantic,
     ObjectSemantic,
     StringSemantic,
+    TupleSemantic,
     UUIDSemantic,
 )
 from conformly._internal.resolver.semantics.dict import DictSemantic
@@ -123,6 +124,9 @@ def _define_allowed_violation_types(
         case DictSemantic(kind=FieldKind.DICT):
             violations = _define_dict_violations(semantic)
 
+        case TupleSemantic(kind=FieldKind.TUPLE):
+            violations = _define_tuple_violations(semantic)
+
         case EnumSemantic(kind=FieldKind.ENUM):
             violations = [ViolationType.NOT_ALLOWED_VALUE]
 
@@ -252,3 +256,20 @@ def _safe_define(semantic: FieldSemantics) -> list[ViolationType]:
         return list(_define_allowed_violation_types(semantic, False, False))
     except PlanningError:
         return []
+
+
+def _define_tuple_violations(semantic: TupleSemantic) -> list[ViolationType]:
+    result: list[ViolationType] = []
+
+    if semantic.is_variadic and semantic.length_range is not None:
+        if semantic.length_range.min_length > 0:
+            result.append(ViolationType.TOO_LESS_ITEMS)
+        if semantic.length_range.max_length is not None:
+            result.append(ViolationType.TOO_MANY_ITEMS)
+
+    for item_semantic, _ in semantic.elements_semantics:
+        for violation in _safe_define(item_semantic):
+            if violation not in result:
+                result.append(violation)
+
+    return result

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/resolver/resolve.py

@@ -13,6 +13,7 @@ from .semantics import (
     NumericSemantic,
     ObjectSemantic,
     StringSemantic,
+    TupleSemantic,
     UUIDSemantic,
 )
 
@@ -74,7 +75,7 @@ def resolve_field(field_spec: FieldSpec, path: FieldPath) -> ResolvedField:
             nested_model=nested,
         )
 
-    if field_spec.collection_type in (list, set, frozenset, tuple) and field_spec.item:
+    if field_spec.collection_type in (list, set, frozenset) and field_spec.item:
         item_semantic, item_nested = resolve_element(field_spec.item, field_spec, path)
 
         list_semantic = create_list_semantics(
@@ -90,6 +91,24 @@ def resolve_field(field_spec: FieldSpec, path: FieldPath) -> ResolvedField:
             nested_model=item_nested,
         )
 
+    if field_spec.collection_type is tuple and field_spec.items is not None:
+        elements: list[tuple[FieldSemantics, ResolvedModel | None]] = []
+        for i, item in enumerate(field_spec.items):
+            item_semantic, item_nested = resolve_element(item, field_spec, (*path, i))
+            elements.append((item_semantic, item_nested))
+
+        return ResolvedField(
+            field_spec=field_spec,
+            path=path,
+            semantic=create_tuple_semantic(
+                constraints=field_spec.collection_constraints,
+                elements_semantics=tuple(elements),
+                is_variadic=len(field_spec.items) == 1,
+                has_constraints=field_spec.has_constraints(),
+            ),
+            nested_model=None,
+        )
+
     if field_spec.collection_type is dict and field_spec.value and field_spec.key:
         if field_spec.key.field_type not in (str, ENUMERATED_TYPE):
             raise ResolutionError(
@@ -544,6 +563,37 @@ def create_list_semantics(
     )
 
 
+def create_tuple_semantic(
+    constraints: tuple[Constraint, ...],
+    elements_semantics: tuple[tuple[FieldSemantics, ResolvedModel | None], ...],
+    is_variadic: bool,
+    has_constraints: bool,
+) -> TupleSemantic:
+    _, length_range, _ = _resolve_collection_constraints(constraints)
+
+    if not is_variadic:
+        fixed_length = len(elements_semantics)
+        min_length = length_range.min_length or fixed_length
+        max_length = (
+            length_range.max_length
+            if length_range.max_length is not None
+            else fixed_length
+        )
+        if min_length > fixed_length or max_length < fixed_length:
+            raise SchemaError(
+                "Tuple length constraints do not match fixed tuple length",
+                context={"code": "invalid_tuple_length_range", "length": fixed_length},
+            )
+        length_range = LengthRange(fixed_length, fixed_length)
+
+    return TupleSemantic(
+        elements_semantics=elements_semantics,
+        length_range=length_range,
+        is_variadic=is_variadic,
+        has_constraints=has_constraints,
+    )
+
+
 def create_dict_semantic(
     constraints: tuple[Constraint, ...],
     key_semantic: FieldSemantics,

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/resolver/semantics/__init__.py

@@ -5,6 +5,7 @@ from .list import ListSemantic
 from .numeric import NumericSemantic
 from .object import ObjectSemantic
 from .string import StringSemantic
+from .tuple import TupleSemantic
 from .uuid import UUIDSemantic
 
 FieldSemantics = (
@@ -16,6 +17,7 @@ FieldSemantics = (
     | ListSemantic
     | UUIDSemantic
     | DictSemantic
+    | TupleSemantic
 )
 
 
@@ -28,5 +30,6 @@ __all__ = [
     "NumericSemantic",
     "ObjectSemantic",
     "StringSemantic",
+    "TupleSemantic",
     "UUIDSemantic",
 ]

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/resolver/semantics/factory.py

@@ -6,6 +6,7 @@ from .list import ListSemantic
 from .numeric import NumericSemantic
 from .object import ObjectSemantic
 from .string import StringSemantic
+from .tuple import TupleSemantic
 from .uuid import UUIDSemantic
 
 from conformly._internal.types import FieldKind, LengthRange, Range
@@ -66,5 +67,19 @@ def create_minimal_semantic(kind: FieldKind) -> FieldSemantics:
             )
         case FieldKind.UUID:
             return UUIDSemantic()
+        case FieldKind.TUPLE:
+            return TupleSemantic(
+                elements_semantics=(
+                    (
+                        StringSemantic(
+                            kind=FieldKind.STRING,
+                            length_range=LengthRange(0, None),
+                            pattern=None,
+                        ),
+                        None,
+                    ),
+                ),
+                is_variadic=True,
+            )
         case _:
             raise ValueError(f"Unsupported FieldKind: {kind}")

conformly-0.7.2/src/conformly/_internal/resolver/semantics/tuple.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from .base import BaseSemantic
+
+from conformly._internal.types import FieldKind, LengthRange
+
+if TYPE_CHECKING:
+    from ..models import ResolvedModel
+    from . import FieldSemantics
+
+
+@dataclass(frozen=True, slots=True)
+class TupleSemantic(BaseSemantic):
+    elements_semantics: tuple[tuple["FieldSemantics", "ResolvedModel | None"], ...]
+    length_range: LengthRange | None = None
+    is_variadic: bool = False
+
+    @property
+    def kind(self) -> FieldKind:
+        return FieldKind.TUPLE

{conformly-0.7.1 → conformly-0.7.2}/src/conformly/_internal/types/primitives.py

@@ -23,6 +23,7 @@ class FieldKind(Enum):
     # collections
     LIST = "list"
     DICT = "dict"
+    TUPLE = "tuple"
 
 
 class ViolationType(Enum):

{conformly-0.7.1 → conformly-0.7.2/src/conformly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conformly
-Version: 0.7.1
+Version: 0.7.2
 Summary: Generate valid & invalid test data from your typed schemas
 Author-email: Nikita Shabanov <nik.shabanov2024@gmail.com>
 License: MIT
@@ -561,6 +561,24 @@ case(Model)
 
 This ensures consistent output format (list) while preserving uniqueness guarantees.
 
+### Tuple support
+
+Fixed tuples and variadic tuples (`tuple[T, ...]`) are generated in their declared
+order. Element annotations and nested models are handled independently:
+
+```python
+@dataclass
+class Event:
+    point: tuple[float, float]
+    labels: tuple[str, ...]
+
+case(Event, valid=True)
+# -> {"point": (1.2, 3.4), "labels": ("abc", "def")}
+```
+
+For invalid generation, a constrained tuple element is selected and invalidated
+without changing the other elements.
+
 ### Dict support
 
 `conformly` supports generation of `dict[K, V]`, where K must be a hashable type (`str` or `Enum`) and `V` can be any supported type (primitives, nested models, etc.).
@@ -621,7 +639,7 @@ from conformly.tracer import Tracer
 
 tracer = Tracer()
 
-payload = case(User, valid=True, tracer=tracer)
+payload = case(User, valid=False, tracer=tracer)
 
 trace = tracer.build()
 

{conformly-0.7.1 → conformly-0.7.2}/src/conformly.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ src/conformly/_internal/generator/types/ipv6.py
 src/conformly/_internal/generator/types/ipvany.py
 src/conformly/_internal/generator/types/list.py
 src/conformly/_internal/generator/types/string.py
+src/conformly/_internal/generator/types/tuple.py
 src/conformly/_internal/generator/types/url.py
 src/conformly/_internal/generator/types/uuid.py
 src/conformly/_internal/parser/__init__.py
@@ -86,6 +87,7 @@ src/conformly/_internal/resolver/semantics/list.py
 src/conformly/_internal/resolver/semantics/numeric.py
 src/conformly/_internal/resolver/semantics/object.py
 src/conformly/_internal/resolver/semantics/string.py
+src/conformly/_internal/resolver/semantics/tuple.py
 src/conformly/_internal/resolver/semantics/uuid.py
 src/conformly/_internal/types/__init__.py
 src/conformly/_internal/types/constants.py