tango-python 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

tango/__init__.py

@@ -44,7 +44,7 @@ from .webhooks import (
 )
 from .webhooks.receiver import Delivery, WebhookReceiver
 
-__version__ = "1.1.1"
+__version__ = "1.1.3"
 __all__ = [
     "TangoClient",
     "TangoAPIError",

tango/client.py

@@ -1923,15 +1923,37 @@ class TangoClient:
         )
 
     # Business Types endpoints
-    def list_business_types(self, page: int = 1, limit: int = 25) -> PaginatedResponse:
-        """List business types"""
-        params = {"page": page, "limit": min(limit, 100)}
+    def list_business_types(
+        self,
+        page: int = 1,
+        limit: int = 25,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
+    ) -> PaginatedResponse:
+        """List business types.
+
+        When ``shape`` is omitted the API applies its own default
+        (``name,code``) and results are returned as :class:`BusinessType`
+        instances. When ``shape`` is provided, raw dicts are returned so the
+        caller can rely on the exact shape requested.
+        """
+        params: dict[str, Any] = {"page": page, "limit": min(limit, 100)}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
         data = self._get("/api/business_types/", params)
+        results: list[Any] = (
+            list(data["results"]) if shape else [BusinessType(**btype) for btype in data["results"]]
+        )
         return PaginatedResponse(
             count=data["count"],
             next=data.get("next"),
             previous=data.get("previous"),
-            results=[BusinessType(**btype) for btype in data["results"]],
+            results=results,
         )
 
     def list_naics(
@@ -1945,8 +1967,17 @@ class TangoClient:
         revenue_limit_gte: int | None = None,
         revenue_limit_lte: int | None = None,
         search: str | None = None,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
     ) -> PaginatedResponse:
-        """List NAICS codes (`/api/naics/`)."""
+        """List NAICS codes (`/api/naics/`).
+
+        When ``shape`` is omitted the API applies its own default. Passing any
+        of the ``revenue_limit*`` / ``employee_limit*`` filters causes the API
+        to widen the default shape to include ``size_standards`` and
+        ``federal_obligations``.
+        """
         params: dict[str, Any] = {"page": page, "limit": min(limit, 100)}
         if employee_limit is not None:
             params["employee_limit"] = employee_limit
@@ -1962,6 +1993,12 @@ class TangoClient:
             params["revenue_limit_lte"] = revenue_limit_lte
         if search is not None:
             params["search"] = search
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
         data = self._get("/api/naics/", params)
         return PaginatedResponse(
             count=data.get("count", 0),
@@ -2081,11 +2118,36 @@ class TangoClient:
         data = self._get(f"/api/entities/{key}/", params)
         return self._parse_response_with_shape(data, shape, Entity, flat, flat_lists)
 
-    def get_entity_budget_flows(self, uei: str) -> dict[str, Any]:
-        """Get budget flows for an entity (`/api/entities/{uei}/budget-flows/`)."""
+    def get_entity_budget_flows(
+        self,
+        uei: str,
+        page: int = 1,
+        limit: int = 25,
+        fiscal_year: int | None = None,
+    ) -> PaginatedResponse[dict[str, Any]]:
+        """Get budget flows for an entity (`/api/entities/{uei}/budget-flows/`).
+
+        Standard page/limit pagination (default 25, max 100). Each result row
+        is a hand-built dict from the backend (no shape system).
+
+        Args:
+            uei: Entity UEI. Required.
+            page: Page number.
+            limit: Results per page (max 100).
+            fiscal_year: Optional fiscal year filter.
+        """
         if not uei:
             raise TangoValidationError("UEI is required")
-        return self._get(f"/api/entities/{uei}/budget-flows/")
+        params: dict[str, Any] = {"page": page, "limit": min(limit, 100)}
+        if fiscal_year is not None:
+            params["fiscal_year"] = fiscal_year
+        data = self._get(f"/api/entities/{uei}/budget-flows/", params)
+        return PaginatedResponse(
+            count=int(data.get("count", 0)),
+            next=data.get("next"),
+            previous=data.get("previous"),
+            results=list(data.get("results") or []),
+        )
 
     # Forecast endpoints
     def list_forecasts(
@@ -3319,9 +3381,22 @@ class TangoClient:
             raise TangoValidationError("Department code is required")
         return self._get(f"/api/departments/{code}/")
 
-    def list_psc(self, page: int = 1, limit: int = 25) -> PaginatedResponse[dict[str, Any]]:
+    def list_psc(
+        self,
+        page: int = 1,
+        limit: int = 25,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
+    ) -> PaginatedResponse[dict[str, Any]]:
         """List Product Service Codes (`/api/psc/`)."""
         params: dict[str, Any] = {"page": page, "limit": min(limit, 100)}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
         data = self._get("/api/psc/", params)
         return PaginatedResponse(
             count=int(data.get("count", 0)),
@@ -3330,11 +3405,24 @@ class TangoClient:
             results=list(data.get("results") or []),
         )
 
-    def get_psc(self, code: str) -> dict[str, Any]:
+    def get_psc(
+        self,
+        code: str,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
+    ) -> dict[str, Any]:
         """Get a Product Service Code by code (`/api/psc/{code}/`)."""
         if not code:
             raise TangoValidationError("PSC code is required")
-        return self._get(f"/api/psc/{code}/")
+        params: dict[str, Any] = {}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
+        return self._get(f"/api/psc/{code}/", params)
 
     def get_psc_metrics(self, code: str, months: int, period_grouping: str) -> dict[str, Any]:
         """Get rolling PSC metrics (`/api/psc/{code}/metrics/{months}/{period_grouping}/`).
@@ -3349,11 +3437,24 @@ class TangoClient:
             raise TangoValidationError("PSC code is required")
         return self._get(f"/api/psc/{code}/metrics/{months}/{period_grouping}/")
 
-    def get_naics(self, code: str) -> dict[str, Any]:
+    def get_naics(
+        self,
+        code: str,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
+    ) -> dict[str, Any]:
         """Get a NAICS code by code (`/api/naics/{code}/`)."""
         if not code:
             raise TangoValidationError("NAICS code is required")
-        return self._get(f"/api/naics/{code}/")
+        params: dict[str, Any] = {}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
+        return self._get(f"/api/naics/{code}/", params)
 
     def get_naics_metrics(self, code: str, months: int, period_grouping: str) -> dict[str, Any]:
         """Get rolling NAICS metrics (`/api/naics/{code}/metrics/{months}/{period_grouping}/`)."""
@@ -3361,17 +3462,41 @@ class TangoClient:
             raise TangoValidationError("NAICS code is required")
         return self._get(f"/api/naics/{code}/metrics/{months}/{period_grouping}/")
 
-    def get_business_type(self, code: str) -> dict[str, Any]:
+    def get_business_type(
+        self,
+        code: str,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
+    ) -> dict[str, Any]:
         """Get a business type by code (`/api/business_types/{code}/`)."""
         if not code:
             raise TangoValidationError("Business type code is required")
-        return self._get(f"/api/business_types/{code}/")
+        params: dict[str, Any] = {}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
+        return self._get(f"/api/business_types/{code}/", params)
 
     def list_assistance_listings(
-        self, page: int = 1, limit: int = 25
+        self,
+        page: int = 1,
+        limit: int = 25,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
     ) -> PaginatedResponse[dict[str, Any]]:
         """List Assistance Listings (CFDA programs) (`/api/assistance_listings/`)."""
         params: dict[str, Any] = {"page": page, "limit": min(limit, 100)}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
         data = self._get("/api/assistance_listings/", params)
         return PaginatedResponse(
             count=int(data.get("count", 0)),
@@ -3380,22 +3505,44 @@ class TangoClient:
             results=list(data.get("results") or []),
         )
 
-    def get_assistance_listing(self, number: str) -> dict[str, Any]:
+    def get_assistance_listing(
+        self,
+        number: str,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
+    ) -> dict[str, Any]:
         """Get an Assistance Listing by CFDA number (`/api/assistance_listings/{number}/`)."""
         if not number:
             raise TangoValidationError("Assistance listing number is required")
-        return self._get(f"/api/assistance_listings/{number}/")
+        params: dict[str, Any] = {}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
+        return self._get(f"/api/assistance_listings/{number}/", params)
 
     def list_mas_sins(
         self,
         page: int = 1,
         limit: int = 25,
         search: str | None = None,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
     ) -> PaginatedResponse[dict[str, Any]]:
         """List GSA MAS SINs (`/api/mas_sins/`)."""
         params: dict[str, Any] = {"page": page, "limit": min(limit, 100)}
         if search is not None:
             params["search"] = search
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
         data = self._get("/api/mas_sins/", params)
         return PaginatedResponse(
             count=int(data.get("count", 0)),
@@ -3404,11 +3551,24 @@ class TangoClient:
             results=list(data.get("results") or []),
         )
 
-    def get_mas_sin(self, sin: str) -> dict[str, Any]:
+    def get_mas_sin(
+        self,
+        sin: str,
+        shape: str | None = None,
+        flat: bool = False,
+        flat_lists: bool = False,
+    ) -> dict[str, Any]:
         """Get a MAS SIN by code (`/api/mas_sins/{sin}/`)."""
         if not sin:
             raise TangoValidationError("MAS SIN is required")
-        return self._get(f"/api/mas_sins/{sin}/")
+        params: dict[str, Any] = {}
+        if shape:
+            params["shape"] = shape
+            if flat:
+                params["flat"] = "true"
+            if flat_lists:
+                params["flat_lists"] = "true"
+        return self._get(f"/api/mas_sins/{sin}/", params)
 
     # ============================================================================
     # Entity sub-resources

tango/shapes/factory.py

@@ -23,7 +23,7 @@ import logging
 from collections.abc import Callable
 from datetime import date, datetime
 from decimal import Decimal
-from typing import Any
+from typing import Any, cast
 
 from tango.exceptions import ModelInstantiationError
 from tango.shapes.generator import TypeGenerator
@@ -542,38 +542,6 @@ class ModelFactory:
                             # Value is not a dict - might be a primitive or None
                             result[result_field_name] = value
 
-                elif field_spec.is_wildcard:
-                    # Wildcard on nested field - use full model type
-                    # This is handled at the top level, but we need to handle it here too
-                    # for nested wildcards like recipient(*)
-                    if field_schema.nested_model:
-                        if field_schema.is_list:
-                            if isinstance(value, list):
-                                nested_instances = []
-                                for item in value:
-                                    if isinstance(item, dict):
-                                        # Parse all fields from the nested model
-                                        nested_instance = self._parse_nested_wildcard(
-                                            item, field_schema.nested_model
-                                        )
-                                        nested_instances.append(nested_instance)
-                                    else:
-                                        nested_instances.append(item)
-                                result[result_field_name] = nested_instances
-                            else:
-                                result[result_field_name] = value
-                        else:
-                            if isinstance(value, dict):
-                                nested_instance = self._parse_nested_wildcard(
-                                    value, field_schema.nested_model
-                                )
-                                result[result_field_name] = nested_instance
-                            else:
-                                result[result_field_name] = value
-                    else:
-                        # Not a nested model, just use the value
-                        result[result_field_name] = value
-
                 else:
                     # Simple field - parse using appropriate parser
                     parsed_value = self._parse_field(
@@ -661,7 +629,7 @@ class ModelFactory:
                     raise ModelInstantiationError(
                         f"Could not resolve nested model '{nested_model}'"
                     )
-                return model_class
+                return cast(type, model_class)
             except ImportError as err:
                 raise ModelInstantiationError(
                     f"Could not import models module to resolve '{nested_model}'"
@@ -704,41 +672,6 @@ class ModelFactory:
         # Recursively create nested instance
         return self.create_instance(data, nested_shape, resolved_model, nested_type)
 
-    def _parse_nested_wildcard(
-        self, data: dict[str, Any], nested_model: type | str
-    ) -> dict[str, Any]:
-        """Parse nested object with wildcard (all fields)
-
-        Args:
-            data: Nested object data
-            nested_model: Model class or string name for the nested object
-
-        Returns:
-            Dictionary with all parsed fields
-        """
-        # Resolve nested model if it's a string
-        resolved_model = self._resolve_nested_model(nested_model)
-
-        # Ensure model is registered
-        if not self.schema_registry.is_registered(resolved_model):
-            self.schema_registry.register(resolved_model)
-
-        # Get model schema
-        model_schema = self.schema_registry.get_schema(resolved_model)
-
-        # Parse all fields
-        result: dict[str, Any] = {}
-        for field_name, value in data.items():
-            if field_name in model_schema:
-                field_schema = model_schema[field_name]
-                parsed_value = self._parse_field(field_name, value, field_schema.type, field_schema)
-                result[field_name] = parsed_value
-            else:
-                # Field not in schema, include as-is
-                result[field_name] = value
-
-        return result
-
     def _parse_field(self, field_name: str, value: Any, field_type: type, field_schema: Any) -> Any:
         """Parse a single field value using appropriate parser
 
@@ -778,7 +711,7 @@ class ModelFactory:
         return value
 
     def validate_data(
-        self, data: dict[str, Any], shape_spec: ShapeSpec, base_model: type
+        self, data: dict[str, Any], shape_spec: ShapeSpec, base_model: type | str
     ) -> list[str]:
         """Validate that data matches the shape specification
 
@@ -803,11 +736,15 @@ class ModelFactory:
         errors: list[str] = []
 
         if not isinstance(data, dict):
-            errors.append(f"Expected dictionary data, got {type(data).__name__}")
+            errors.append(  # type: ignore[unreachable]
+                f"Expected dictionary data, got {type(data).__name__}"
+            )
             return errors
 
-        # Ensure model is registered
-        if not self.schema_registry.is_registered(base_model):
+        # Ensure model is registered. String model names are expected to be
+        # pre-registered (explicit schemas); only concrete classes can be
+        # auto-registered via introspection.
+        if isinstance(base_model, type) and not self.schema_registry.is_registered(base_model):
             self.schema_registry.register(base_model)
 
         # Get model schema
@@ -826,9 +763,8 @@ class ModelFactory:
 
             # Check if field exists in schema
             if field_spec.name not in model_schema:
-                errors.append(
-                    f"Field '{field_spec.name}' does not exist in {base_model.__name__} schema"
-                )
+                model_name = base_model.__name__ if isinstance(base_model, type) else base_model
+                errors.append(f"Field '{field_spec.name}' does not exist in {model_name} schema")
                 continue
 
             field_schema = model_schema[field_spec.name]

tango/shapes/generator.py

@@ -20,7 +20,7 @@ Examples:
 import logging
 import threading
 from collections import OrderedDict
-from typing import Any, get_args, get_origin, get_type_hints
+from typing import Any, cast, get_args, get_origin, get_type_hints
 
 from tango.exceptions import TypeGenerationError
 from tango.shapes.models import ShapeSpec
@@ -250,7 +250,10 @@ class TypeGenerator:
 
                 field_schema = model_schema[field_spec.name]
 
-                # Determine field type
+                # Determine field type. The value is a heterogeneous mix of type
+                # objects, parameterized generics (list[...]), and union objects,
+                # so it is intentionally typed as Any.
+                field_type: Any
                 if field_spec.nested_fields:
                     # Generate nested type
                     if not field_schema.nested_model:
@@ -275,25 +278,7 @@ class TypeGenerator:
 
                     # Handle optional types
                     if field_schema.is_optional:
-                        field_type = field_type | None  # type: ignore
-
-                    annotations[field_name] = field_type
-
-                elif field_spec.is_wildcard:
-                    # Wildcard on nested field - use full model type
-                    if field_schema.nested_model:
-                        # Resolve nested model if it's a string
-                        field_type = self._resolve_nested_model(field_schema.nested_model)
-                    else:
-                        field_type = field_schema.type
-
-                    # Handle list types
-                    if field_schema.is_list:
-                        field_type = list[field_type]  # type: ignore
-
-                    # Handle optional types
-                    if field_schema.is_optional:
-                        field_type = field_type | None  # type: ignore
+                        field_type = field_type | None
 
                     annotations[field_name] = field_type
 
@@ -303,11 +288,11 @@ class TypeGenerator:
 
                     # Handle list types
                     if field_schema.is_list:
-                        field_type = list[field_type]  # type: ignore
+                        field_type = list[field_type]
 
                     # Handle optional types
                     if field_schema.is_optional:
-                        field_type = field_type | None  # type: ignore
+                        field_type = field_type | None
 
                     annotations[field_name] = field_type
 
@@ -329,7 +314,7 @@ class TypeGenerator:
                     field_type = field_schema.type
                     # Handle optional types
                     if field_schema.is_optional:
-                        field_type = field_type | None  # type: ignore
+                        field_type = field_type | None
                     annotations[auto_field] = field_type
 
             # Create TypedDict dynamically
@@ -414,7 +399,7 @@ class TypeGenerator:
                 model_class = getattr(models, nested_model, None)
                 if model_class is None:
                     raise TypeGenerationError(f"Could not resolve nested model '{nested_model}'")
-                return model_class
+                return cast(type, model_class)
             except ImportError as err:
                 raise TypeGenerationError(
                     f"Could not import models module to resolve '{nested_model}'"
@@ -555,7 +540,7 @@ class TypeGenerator:
 
         # Handle basic types
         if hasattr(type_annotation, "__name__"):
-            type_name = type_annotation.__name__
+            type_name = str(type_annotation.__name__)
         else:
             type_name = str(type_annotation)
 
@@ -576,7 +561,7 @@ class TypeGenerator:
                 if args:
                     formatted_args = [self._format_type_annotation(arg) for arg in args]
                     return f"{origin.__name__}[{', '.join(formatted_args)}]"
-                return origin.__name__
+                return str(origin.__name__)
 
         return type_name
 

tango/shapes/parser.py

@@ -110,7 +110,7 @@ def _suggest_field_correction(invalid_field: str, valid_fields: list[str]) -> st
 
     # Check for common prefix
     best_match = None
-    best_score = 0
+    best_score = 0.0
 
     for field in valid_fields:
         # Count common prefix length
@@ -167,6 +167,13 @@ class ShapeParser:
         self._schema_registry = schema_registry
         self._schema_registry_initialized = schema_registry is not None
 
+    def _ensure_registry(self) -> SchemaRegistry:
+        """Return the schema registry, lazily creating it on first use."""
+        if self._schema_registry is None:
+            self._schema_registry = SchemaRegistry()
+            self._schema_registry_initialized = True
+        return self._schema_registry
+
     def parse(self, shape: str) -> ShapeSpec:
         """Parse a shape string into a ShapeSpec
 
@@ -544,25 +551,22 @@ class ShapeParser:
             >>> spec = parser.parse("invalid_field")
             >>> parser.validate(spec, Contract)  # Raises ShapeValidationError
         """
-        # Lazy initialize schema registry
-        if not self._schema_registry_initialized:
-            self._schema_registry = SchemaRegistry()
-            self._schema_registry_initialized = True
+        registry = self._ensure_registry()
 
         # Ensure model is registered
-        if not self._schema_registry.is_registered(model_class):
-            self._schema_registry.register(model_class)
+        if not registry.is_registered(model_class):
+            registry.register(model_class)
 
         # Validate each field
         for field_spec in shape_spec.fields:
             self._validate_field_spec(field_spec, model_class)
 
-    def _validate_field_spec(self, field_spec: FieldSpec, model_class: type) -> None:
+    def _validate_field_spec(self, field_spec: FieldSpec, model_class: type | str) -> None:
         """Validate a single field specification against a model
 
         Args:
             field_spec: Field specification to validate
-            model_class: Model class to validate against
+            model_class: Model class (or registered model name) to validate against
 
         Raises:
             ShapeValidationError: If field is invalid
@@ -571,20 +575,17 @@ class ShapeParser:
         if field_spec.is_wildcard:
             return
 
-        # Lazy initialize schema registry if needed
-        if not self._schema_registry_initialized:
-            self._schema_registry = SchemaRegistry()
-            self._schema_registry_initialized = True
+        registry = self._ensure_registry()
 
         # Validate field exists in model
         try:
-            field_schema = self._schema_registry.validate_field(model_class, field_spec.name)
+            field_schema = registry.validate_field(model_class, field_spec.name)
         except ShapeValidationError as e:
             # Enhance error message with suggestions
             model_name = (
                 model_class.__name__ if hasattr(model_class, "__name__") else str(model_class)
             )
-            model_schema = self._schema_registry.get_schema(model_class)
+            model_schema = registry.get_schema(model_class)
             valid_fields = list(model_schema.keys())
 
             error_msg = f"Field '{field_spec.name}' does not exist in {model_name}."
@@ -630,7 +631,7 @@ class ShapeParser:
                 error_msg += "\n\nNested selections are only valid for object fields like 'recipient', 'agency', 'location', etc."
 
                 # Find some nested fields as examples
-                model_schema = self._schema_registry.get_schema(model_class)
+                model_schema = registry.get_schema(model_class)
                 nested_examples = [
                     name for name, schema in model_schema.items() if schema.nested_model
                 ]

tango/shapes/schema.py

@@ -8,6 +8,7 @@ the dynamic-only model approach. These schemas define field types, nested models
 list indicators independently of the dataclass definitions.
 """
 
+import builtins
 from dataclasses import dataclass
 from typing import Any, get_args, get_origin, get_type_hints
 
@@ -33,10 +34,10 @@ class FieldSchema:
     """
 
     name: str
-    type: type
+    type: builtins.type
     is_optional: bool
     is_list: bool
-    nested_model: type | None = None
+    nested_model: builtins.type | str | None = None
 
     def __repr__(self) -> str:
         """String representation for debugging"""

{tango_python-1.1.1.dist-info → tango_python-1.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tango-python
-Version: 1.1.1
+Version: 1.1.3
 Summary: Python SDK for the Tango API
 Project-URL: Homepage, https://github.com/makegov/tango-python
 Project-URL: Documentation, https://docs.makegov.com/tango-python

{tango_python-1.1.1.dist-info → tango_python-1.1.3.dist-info}/RECORD

@@ -1,22 +1,22 @@
-tango/__init__.py,sha256=3H_QVdoCe1ziPTZePlkIoA7j1jcZ11gotzZ2NslWms0,1912
-tango/client.py,sha256=CAejxkwhyMwisVMGSdVqlKGkSNfNT7G60MtZb6BtEYk,143984
+tango/__init__.py,sha256=GFajAGv2H7jhE0yuU7wJk8qOqEARV7Mg2bFIelwsodE,1912
+tango/client.py,sha256=3rZO03j-it7X0BP1EDJSpj5MVOV8JXtnC7AL2pijobQ,148758
 tango/exceptions.py,sha256=aRvDm0dUCEtNDfRVYCX7SEDdd1WlIVVY6sN78Tzo-a0,3114
 tango/models.py,sha256=QqUPtO7HJJDUaJDAMUkzvqR7pj1YIr8BetbS4palxc0,34261
 tango/shapes/__init__.py,sha256=7ea1WU74jp4znhNw-gXruag6m6eyPZtbVgbDFmFUWro,1072
 tango/shapes/explicit_schemas.py,sha256=8HgxKpAi2U80JP_MnABnW1JpYJA05aoOZSJsJIcyIWQ,71421
-tango/shapes/factory.py,sha256=ytpMi5Uw72XZ8MimhuSsLDVXF3zO_Zt3_tAL6NF7LnU,34318
-tango/shapes/generator.py,sha256=61V1T3lm8Ps_KSMJAezQJLQVFbNKt1jtoLyhiqNtFTs,23380
+tango/shapes/factory.py,sha256=uDPhnp6VVzrLBKodxteZy5AcU43juEv-qKVRWth51j0,31550
+tango/shapes/generator.py,sha256=xzakpwTwqTMUr89I06hp54-FIYZziviWHk2Glscg-LM,22775
 tango/shapes/models.py,sha256=h3pIhOqrrdlN953Y6r0oney5HFbKPOD-frRndRWimJ0,3018
-tango/shapes/parser.py,sha256=-2Ap5jgeAvKsKtA-MaXPGE6PRB93GPV8GK99Z0geW_s,27468
-tango/shapes/schema.py,sha256=VRPOB1sBdjFyimNchrZKIpTHn83CyX4RfU9077aQtIU,14136
+tango/shapes/parser.py,sha256=AecNx5oT_hV_pf2AWZnsR8Y2aLmCtjfgS9-znA2Pesc,27429
+tango/shapes/schema.py,sha256=ZdiNuqWCRhmpyLag8xtlQcoyyqvkpDqrr7xu2YbhaOY,14176
 tango/shapes/types.py,sha256=27jrAE0VIdrKaLjR_FK71hfIIGX2Tg3ex7REEBV1TFE,1301
 tango/webhooks/__init__.py,sha256=3bbiiGoB3s5iqqmQceroN0-MCSm-ZOZQx3M6JAknIUo,774
 tango/webhooks/cli.py,sha256=f_vQbJ2AeSQjKnQo7MxHFyUB2SAKcgHYmGQULS0isqQ,13858
 tango/webhooks/receiver.py,sha256=5yhsVhlLyoxmOCGvmbynWAIlDB2OaCPVf1H4GA1SxmU,9279
 tango/webhooks/signing.py,sha256=92Ee-0B6PR7ZkvY3Np3gzl88-mtfKkh-I7lxqCe2lGw,2374
 tango/webhooks/simulate.py,sha256=g2Osa0FYU5mJuon07T2aUCtmkUoTEzsY261tlp76fF0,3165
-tango_python-1.1.1.dist-info/METADATA,sha256=lUFYfhe3_JPafL82HboUatKTDzWWVeemou58w5ofYFo,20599
-tango_python-1.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-tango_python-1.1.1.dist-info/entry_points.txt,sha256=kGLUbglUjuaAqEFvOZ1QuSW0vWb6VeSpCIFKaOFkKoQ,50
-tango_python-1.1.1.dist-info/licenses/LICENSE,sha256=j2kYVHMwTkoGn3ZNScnrdIueG0k2XzB_LCPFoyBc2wk,1064
-tango_python-1.1.1.dist-info/RECORD,,
+tango_python-1.1.3.dist-info/METADATA,sha256=dvg8fyZFIcwz6xkS1J40HFHjtAxtIAfsolxz0RIM3aw,20599
+tango_python-1.1.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+tango_python-1.1.3.dist-info/entry_points.txt,sha256=kGLUbglUjuaAqEFvOZ1QuSW0vWb6VeSpCIFKaOFkKoQ,50
+tango_python-1.1.3.dist-info/licenses/LICENSE,sha256=j2kYVHMwTkoGn3ZNScnrdIueG0k2XzB_LCPFoyBc2wk,1064
+tango_python-1.1.3.dist-info/RECORD,,

{tango_python-1.1.1.dist-info → tango_python-1.1.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any