jentic-openapi-datamodels 1.0.0a11__py3-none-any.whl → 1.0.0a13__py3-none-any.whl

jentic/apitools/openapi/datamodels/low/v30/specification_object.py

@@ -1,217 +0,0 @@
-"""Base class for OpenAPI specification objects."""
-
-from abc import ABC
-from collections.abc import Mapping, MutableMapping, Sequence
-from copy import copy
-from typing import Any, Iterator, TypeVar
-
-
-__all__ = ["SpecificationObject"]
-
-
-T = TypeVar("T", bound="SpecificationObject")
-
-
-class SpecificationObject(ABC, MutableMapping[str, Any]):
-    """
-    Base class for OpenAPI specification objects.
-
-    Implements a MutableMapping interface with data stored in __dict__.
-    Subclasses become dict-like objects where all attributes are accessible
-    via both attribute access (obj.foo) and item access (obj["foo"]).
-
-    Class Attributes:
-        _supports_extensions: Whether this object type supports x-* specification extensions.
-                             Default is True. Set to False for objects like Security Requirement
-                             that are pure maps where x-* are regular keys.
-    """
-
-    _supports_extensions: bool = False
-
-    def __init__(self, data: Mapping[str, Any] | None = None):
-        """
-        Initialize a SpecificationObject.
-
-        Args:
-            data: Optional mapping to initialize the object with
-        """
-        if data:
-            for key, value in data.items():
-                self[key] = self._copy_value(value)
-
-    # MutableMapping abstract methods
-    def __getitem__(self, key: str) -> Any:
-        """Get an item."""
-        return self.__dict__[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        """Set an item."""
-        self.__dict__[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        """Delete an item."""
-        del self.__dict__[key]
-
-    def __iter__(self) -> Iterator[str]:
-        """Iterate over keys."""
-        return iter(self.__dict__)
-
-    def __len__(self) -> int:
-        """Return the number of items."""
-        return len(self.__dict__)
-
-    def __getattr__(self, name: str) -> Any:
-        """
-        Get an attribute via attribute access.
-
-        This allows both dict-style (obj["key"]) and attribute-style (obj.key) access.
-        Called only when the attribute is not found through normal lookup.
-        """
-        try:
-            return self[name]
-        except KeyError:
-            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        """
-        Set an attribute via attribute access.
-
-        This allows both dict-style (obj["key"] = val) and attribute-style (obj.key = val).
-        For properties and other descriptors, delegates to the descriptor.
-        """
-        # Check if this is a data descriptor (property, etc.) on the class
-        cls = type(self)
-        if hasattr(cls, name):
-            attr = getattr(cls, name)
-            # If it's a data descriptor (has __set__), use normal attribute setting
-            if hasattr(attr, "__set__"):
-                object.__setattr__(self, name, value)
-                return
-        # Otherwise, store in the dict
-        self[name] = value
-
-    def get_extensions(self) -> Mapping[str, Any]:
-        """
-        Get specification extensions (x-* fields).
-
-        Returns a filtered view of fields starting with 'x-'.
-        If this object type doesn't support extensions (_supports_extensions=False),
-        returns an empty mapping.
-
-        Returns:
-            Mapping of extension fields (keys starting with 'x-')
-        """
-        if not type(self)._supports_extensions:
-            return {}
-        return {k: v for k, v in self.items() if isinstance(k, str) and k.startswith("x-")}
-
-    def get_fields(self) -> Mapping[str, Any]:
-        """
-        Get regular fields (non-extension fields).
-
-        Returns a filtered view excluding fields starting with 'x-'.
-        If this object type doesn't support extensions (_supports_extensions=False),
-        returns all fields (x-* are treated as regular fields).
-
-        Returns:
-            Mapping of regular fields (excluding x-* if extensions are supported)
-        """
-        if not type(self)._supports_extensions:
-            return dict(self)
-        return {k: v for k, v in self.items() if isinstance(k, str) and not k.startswith("x-")}
-
-    @classmethod
-    def from_mapping(cls: type[T], data: Mapping[str, Any]) -> T:
-        """
-        Create an instance from a mapping.
-
-        This method does not validate the structure. Use a separate
-        validator to ensure the data conforms to the OpenAPI specification.
-
-        Args:
-            data: Mapping to create the object from
-
-        Returns:
-            Instance of the class
-
-        Raises:
-            TypeError: If data is not a Mapping
-        """
-        if not isinstance(data, Mapping):
-            raise TypeError(f"Expected Mapping, got {type(data).__name__}")
-        return cls(data=data)
-
-    def to_mapping(self) -> dict[str, Any]:
-        """
-        Convert to a plain dictionary representation.
-
-        Recursively converts nested SpecificationObject instances to plain dicts.
-        Useful for serialization to JSON/YAML.
-
-        Returns:
-            Plain dictionary with all nested objects converted
-        """
-        return {key: self._marshal_value(value) for key, value in MutableMapping.items(self)}
-
-    @classmethod
-    def _marshal_value(cls, value: Any) -> Any:
-        """
-        Helper to recursively marshal values to plain types.
-
-        Uses the actual class (or subclass) to support custom marshaling behavior.
-        """
-        if isinstance(value, SpecificationObject):
-            return value.to_mapping()
-        elif isinstance(value, (list, tuple)):
-            return type(value)(cls._marshal_value(item) for item in value)
-        elif isinstance(value, dict):
-            return {k: cls._marshal_value(v) for k, v in value.items()}
-        else:
-            return value
-
-    @staticmethod
-    def _copy_value(value: Any) -> Any:
-        """
-        Defensive shallow copy for mutable collections.
-
-        Copies mutable types (list, dict, etc.) to prevent unintended mutation
-        of input data. Does not copy SpecificationObjects (already defensive).
-
-        Args:
-            value: Value to potentially copy
-
-        Returns:
-            Copy of value if mutable collection, otherwise value itself
-        """
-
-        # Don't copy SpecificationObjects (already create new instances)
-        if isinstance(value, SpecificationObject):
-            return value
-
-        # Copy mutable collections (dict, list, etc.)
-        # Exclude strings (they're Sequence but immutable)
-        if isinstance(value, (Mapping, Sequence)) and not isinstance(value, str):
-            return copy(value)
-
-        # Primitives and immutables - no copy needed
-        return value
-
-    def __repr__(self) -> str:
-        """Return a developer-friendly string representation."""
-        class_name = self.__class__.__name__
-
-        # Count regular fields and extensions separately
-        extensions = self.get_extensions()
-        ext_count = len(extensions)
-        field_count = len(self) - ext_count
-
-        # Build field part
-        field_word = "field" if field_count == 1 else "fields"
-        parts = [f"{field_count} {field_word}"]
-
-        # Add extensions part if any
-        if ext_count > 0:
-            ext_word = "specification extension" if ext_count == 1 else "specification extensions"
-            parts.append(f"{ext_count} {ext_word}")
-
-        return f"<{class_name} {', '.join(parts)}>"

jentic_openapi_datamodels-1.0.0a11.dist-info/METADATA

@@ -1,52 +0,0 @@
-Metadata-Version: 2.4
-Name: jentic-openapi-datamodels
-Version: 1.0.0a11
-Summary: Jentic OpenAPI Data Models
-Author: Jentic
-Author-email: Jentic <hello@jentic.com>
-License-Expression: Apache-2.0
-License-File: LICENSE
-License-File: NOTICE
-Requires-Python: >=3.11
-Project-URL: Homepage, https://github.com/jentic/jentic-openapi-tools
-Description-Content-Type: text/markdown
-
-# jentic-openapi-datamodels
-
-Low-level and high-level data models for OpenAPI specifications.
-
-## Overview
-
-This package provides data model classes for representing OpenAPI specification objects in Python. The models are designed to be:
-
-- **Dict-like**: Implement `MutableMapping` for easy data access
-- **Unvalidated**: Separate parsing from validation for performance
-- **Extensible**: Support OpenAPI specification extensions (x-* fields)
-- **Version-aware**: Currently implements OpenAPI 3.0.x (3.1.x planned)
-
-## Structure
-
-- `datamodels.low.v30`: Low-level models for OpenAPI 3.0.x
-
-## Usage
-
-```python
-from jentic.apitools.openapi.datamodels.low.v30 import Schema
-
-# Create a schema from raw data
-schema = Schema({
-    "type": "object",
-    "properties": {
-        "name": {"type": "string"}
-    }
-})
-
-# Access via properties
-print(schema.type)  # "object"
-
-# Access via dict
-print(schema["type"])  # "object"
-
-# Convert back to dict
-data = schema.to_mapping()
-```

jentic_openapi_datamodels-1.0.0a11.dist-info/RECORD

@@ -1,18 +0,0 @@
-jentic/apitools/openapi/datamodels/low/v30/__init__.py,sha256=8AUc3qAlQeUD4GZ2JfARDBkLZT8eAjEeYaIWOTprZUM,692
-jentic/apitools/openapi/datamodels/low/v30/discriminator.py,sha256=za2gNfp8k3plfJczMnmNNa-ajlEAxcsbnnYywg3eOuU,2725
-jentic/apitools/openapi/datamodels/low/v30/external_documentation.py,sha256=X_XbyILIQxeIgRk9lHOavv4KmSEwkRn_wQ1ahvMHVMk,2061
-jentic/apitools/openapi/datamodels/low/v30/oauth_flow.py,sha256=TCJBzDvO5sTwWq5v1BCRB8uBLyd4Xc96QvDfg2GAToE,4162
-jentic/apitools/openapi/datamodels/low/v30/oauth_flows.py,sha256=S3ZPwYEUEo57CWZTBHnxGCOXnr-AUHj43jUJByiE7kw,5218
-jentic/apitools/openapi/datamodels/low/v30/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jentic/apitools/openapi/datamodels/low/v30/reference.py,sha256=CeyIeFPChvZ37skuraN20jPNUbxJX44BwZ13I2PWj1M,1782
-jentic/apitools/openapi/datamodels/low/v30/schema.py,sha256=39jR2xVfyiMYn9Q1xPNnEs_Tf8mVaWrN6ZdXN-M45oo,19305
-jentic/apitools/openapi/datamodels/low/v30/security_requirement.py,sha256=GTMKm84DMPZeAj9Xd8V1LAv87LxhSo2wOqmX_dVIMsg,3005
-jentic/apitools/openapi/datamodels/low/v30/security_scheme.py,sha256=FW_AJxV-J8D3BFm7jYZVhkUu-fJrZZOpFXPfPHb7rRw,8128
-jentic/apitools/openapi/datamodels/low/v30/specification_object.py,sha256=h5Tk5DH34LBQxIxPjGKuTHUpPMvlunfCQ4LCsO4f31I,7502
-jentic/apitools/openapi/datamodels/low/v30/tag.py,sha256=ka03JPcuJHZyzPhKneDncCHIaiRgbMlBJgj5L3XGH88,3817
-jentic/apitools/openapi/datamodels/low/v30/xml.py,sha256=bMdf80c22nqw7tDVLiwtYyhlwB1BHjE_CdGZPOEbLYY,3434
-jentic_openapi_datamodels-1.0.0a11.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-jentic_openapi_datamodels-1.0.0a11.dist-info/licenses/NOTICE,sha256=pAOGW-rGw9KNc2cuuLWZkfx0GSTV4TicbgBKZSLPMIs,168
-jentic_openapi_datamodels-1.0.0a11.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-jentic_openapi_datamodels-1.0.0a11.dist-info/METADATA,sha256=GXX9b1_46cw2S5LOOT39UALjZEcYRKHhTDAPoW0bSYs,1346
-jentic_openapi_datamodels-1.0.0a11.dist-info/RECORD,,