json-schema-parser 1.0.0__py3-none-any.whl

json_schema_parser/__init__.py

@@ -0,0 +1 @@
+from json_schema_parser.src import JsonSchemaParser

json_schema_parser/data_types.py

@@ -0,0 +1,159 @@
+import datetime
+from enum import Enum
+from typing import Any, List, Optional, Type, Union, get_args
+from uuid import UUID
+
+
+class DataType(str, Enum):
+    INTEGER = "integer"
+    LIST_INTEGER = "integer[]"
+    OPTIONAL_INTEGER = "integer?"
+    OPTIONAL_LIST_INTEGER = "integer[]?"
+
+    FLOAT = "float"
+    LIST_FLOAT = "float[]"
+    OPTIONAL_FLOAT = "float?"
+    OPTIONAL_LIST_FLOAT = "float[]?"
+
+    STRING = "string"
+    LIST_STRING = "string[]"
+    OPTIONAL_STRING = "string?"
+    OPTIONAL_LIST_STRING = "string[]?"
+
+    BOOLEAN = "boolean"
+    LIST_BOOLEAN = "boolean[]"
+    OPTIONAL_BOOLEAN = "boolean?"
+    OPTIONAL_LIST_BOOLEAN = "boolean[]?"
+
+    JSON = "json"
+    LIST_JSON = "json[]"
+    OPTIONAL_JSON = "json?"
+    OPTIONAL_LIST_JSON = "json[]?"
+
+    UUID = "uuid"
+    LIST_UUID = "uuid[]"
+    OPTIONAL_UUID = "uuid?"
+    OPTIONAL_LIST_UUID = "uuid[]?"
+
+    DATETIME = "datetime"
+    LIST_DATETIME = "datetime[]"
+    OPTIONAL_DATETIME = "datetime?"
+    OPTIONAL_LIST_DATETIME = "datetime[]?"
+
+    @property
+    def is_many(self) -> bool:
+        return "[]" in self.value
+
+    @property
+    def is_optional(self) -> bool:
+        return "?" in self.value
+
+
+PRIMITIVE_TYPES_DICT = {
+    DataType.INTEGER: int,
+    DataType.OPTIONAL_INTEGER: Optional[int],
+    DataType.FLOAT: float,
+    DataType.OPTIONAL_FLOAT: Optional[float],
+    DataType.STRING: str,
+    DataType.OPTIONAL_STRING: Optional[str],
+    DataType.BOOLEAN: bool,
+    DataType.OPTIONAL_BOOLEAN: Optional[bool],
+    DataType.DATETIME: datetime.datetime,
+    DataType.OPTIONAL_DATETIME: Optional[datetime.datetime],
+    DataType.UUID: UUID,
+    DataType.OPTIONAL_UUID: Optional[UUID]
+}
+
+ITERABLE_PRIMITIVE_TYPES_DICT = {
+    DataType.LIST_INTEGER: List[int],
+    DataType.OPTIONAL_LIST_INTEGER: Optional[List[int]],
+    DataType.LIST_FLOAT: List[float],
+    DataType.OPTIONAL_LIST_FLOAT: Optional[List[float]],
+    DataType.LIST_STRING: List[str],
+    DataType.OPTIONAL_LIST_STRING: Optional[List[str]],
+    DataType.LIST_BOOLEAN: List[bool],
+    DataType.OPTIONAL_LIST_BOOLEAN: Optional[List[bool]],
+    DataType.LIST_DATETIME: List[datetime.datetime],
+    DataType.OPTIONAL_LIST_DATETIME: Optional[List[datetime.datetime]],
+    DataType.LIST_UUID: List[UUID],
+    DataType.OPTIONAL_LIST_UUID: Optional[List[UUID]],
+}
+
+COMPLEX_TYPES_DICT = {
+    DataType.JSON: dict,
+    DataType.LIST_JSON: List[dict],
+    DataType.OPTIONAL_JSON: Optional[dict],
+    DataType.OPTIONAL_LIST_JSON: Optional[List[dict]],
+}
+
+FULL_PRIMITIVE_TYPES_DICT = {
+    **PRIMITIVE_TYPES_DICT,
+    **ITERABLE_PRIMITIVE_TYPES_DICT,
+}
+
+PYTHON_TYPES_DICT = {
+    **FULL_PRIMITIVE_TYPES_DICT,
+    **COMPLEX_TYPES_DICT,
+}
+
+PRIMITIVE_TO_DATA_TYPE_LOOKUP = {
+    value: key
+    for key, value in PYTHON_TYPES_DICT.items()
+}
+
+
+def __extract_primitive_type(typing: Type | Union[Type, None]) -> Type | Union[Type, None]:
+
+    extracted_args = get_args(typing)
+    extracted_arg = extracted_args[0] if extracted_args else None
+
+    return typing if not extracted_arg else __extract_primitive_type(extracted_arg)
+
+
+def extract_primitive_type(data_type: DataType) -> Any:
+    typing = PYTHON_TYPES_DICT[data_type]
+    return __extract_primitive_type(typing)
+
+
+def is_default_value_valid(value: Any, data_type: DataType) -> bool:
+    if value is ...:  # Ellipsis means "required / no default" — always valid
+        return True
+    PrimitiveType = extract_primitive_type(data_type)
+    if data_type.is_many:
+        # if value is list of JSON then optional value should be list or None.
+        if data_type == DataType.OPTIONAL_LIST_JSON:
+            return (isinstance(value, list) and len(value) == 0) or value is None
+
+        return isinstance(value, list) and all(
+            isinstance(item, (PrimitiveType, type(None))) for item in value
+        )
+    else:
+        # if value is JSON then optional value should be None.
+        if data_type == DataType.OPTIONAL_JSON:
+            return value is None
+
+        return isinstance(value, (PrimitiveType, type(None)))
+
+
+def get_default_value(data_type: DataType, default_value: Any) -> Any:
+    # TODO: Adjust flow for validation before getting default value.
+    if default_value is None:
+        return None if data_type.is_optional else ...
+
+    PrimitiveType = extract_primitive_type(data_type)
+
+    data_type_coersion_constructor_lookup = {
+        datetime.datetime: datetime.datetime.fromisoformat,
+        UUID: UUID,
+    }
+
+    if PrimitiveType in data_type_coersion_constructor_lookup:
+        Constructor = data_type_coersion_constructor_lookup[PrimitiveType]
+        if data_type.is_many:
+            return [
+                Constructor(item) if item is not None else None
+                for item in default_value
+            ]
+        return Constructor(default_value)
+
+    return default_value

json_schema_parser/src.py

@@ -0,0 +1,358 @@
+from datetime import datetime
+from typing import Any, Dict, Tuple, Type, Union, Literal, Optional, List, cast, get_args, get_origin
+from functools import singledispatchmethod
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field, RootModel, field_validator, model_validator, create_model
+from pydantic_core import PydanticUndefined
+from pydantic.fields import FieldInfo
+
+from json_schema_parser.data_types import (
+    PRIMITIVE_TO_DATA_TYPE_LOOKUP,
+    DataType,
+    PYTHON_TYPES_DICT,
+    is_default_value_valid,
+    get_default_value
+)
+
+# Type alias for Pydantic model types
+PydanticModelType = Type[RootModel]
+PydanticModel = BaseModel
+
+
+class SimpleTypeInput(BaseModel):
+    """
+    this class represents the simple type structure of the json schema input
+    """
+    model_config = ConfigDict(
+        extra='forbid'
+    )
+
+    field_type: Literal[
+        DataType.INTEGER,
+        DataType.STRING,
+        DataType.BOOLEAN,
+        DataType.FLOAT,
+        DataType.JSON,
+        DataType.DATETIME,
+        DataType.UUID
+    ]
+    is_many: bool = False
+    is_optional: bool = False
+    field_default_value: Any = None
+    description: str = ""
+
+    @field_validator('field_type', mode='before')
+    def validate_field_type(cls, value):
+        return DataType(value)
+
+    @model_validator(mode='after')
+    def validate_field_default_value(self):
+        if not is_default_value_valid(self.default_value, self.data_type):
+            raise Exception(
+                f"Default value {self.default_value} is invalid for {self.field_type}.")
+        return self
+
+    @property
+    def primitive_type(self) -> Type:
+        python_type = PYTHON_TYPES_DICT[self.data_type]
+        return python_type
+
+    @property
+    def data_type(self) -> DataType:
+        field_type = self.field_type
+        field_type_value = field_type.value
+
+        if self.is_many:
+            field_type_value += '[]'
+        if self.is_optional:
+            field_type_value += '?'
+
+        data_type = DataType(field_type_value)
+
+        return data_type
+
+    @property
+    def default_value(self):
+        default_value = get_default_value(
+            self.data_type, self.field_default_value)
+        return default_value
+
+    @property
+    def pydantic_field(self) -> Tuple[Type, FieldInfo]:
+        return (self.primitive_type, Field(self.default_value, description=self.description))
+
+
+class ComplexTypeInput(
+    RootModel[
+        Dict[
+            str,
+            Union[
+                'ComplexTypeInput',
+                'SimpleTypeInput'
+            ]
+        ]
+    ]
+):
+    """
+    this class represents the complex type structure of the json input
+    which is a dictionary that map the name of the property and the type of it.
+    the type of the property could be SimpleTypeInput or ComplexTypeInput
+    The Request Body will look like so:
+        {
+            "optional_string_list": {
+                "field_type": "string",
+                "is_many": True,
+                "is_optional": True,
+                "field_default_value": [],
+                "description": "Optional string list"
+            },
+            "required_integer": {
+                "field_type": "integer",
+                "is_many": False,
+                "is_optional": False,
+                "field_default_value": None,
+                "description": "Required integer"
+            },
+            "nested_object": {
+                "__config": {
+                    "field_type": "json",
+                    "is_many": False,
+                    "is_optional": False,
+                    "field_default_value": None,
+                    "description": "Nested object"
+                },
+                "nested_string": {
+                    "field_type": "string",
+                    "is_many": False,
+                    "is_optional": False,
+                    "field_default_value": None,
+                    "description": "nested string",
+                }
+            },
+            "nested_object_list": {
+                "__config": {
+                    "field_type": "json",
+                    "is_many": True,
+                    "is_optional": False,
+                    "field_default_value": None,
+                    "description": "Nested object"
+                },
+                "nested_string": {
+                    "field_type": "string",
+                    "is_many": False,
+                    "is_optional": False,
+                    "field_default_value": None,
+                    "description": "nested string",
+                }
+            },
+            "__config": {
+                "field_type": "json",
+                "is_many": False,
+                "is_optional": False,
+                "field_default_value": None,
+                "description": "key description"
+            }
+        }
+    """
+
+    @property
+    def config(self) -> SimpleTypeInput:
+        return cast(SimpleTypeInput, self.root['__config'])
+
+
+class JsonSchemaParser(RootModel[
+    Union[
+        SimpleTypeInput,
+        ComplexTypeInput
+    ]
+]):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True
+    )
+
+    __is_simple_type: Optional[bool] = None  # type: ignore
+    __pydantic_model: Optional[PydanticModelType] = None  # type: ignore
+
+    # this function will be automaticaly executed after pydantic finishing the class initialization
+    def model_post_init(self, __context: dict) -> None:
+        self.__is_simple_type = isinstance(self.root, SimpleTypeInput)
+
+    @property
+    def is_simple_type(self) -> bool:
+        if self.__is_simple_type is None:
+            raise Exception("The model post init hasn't been executed yet.")
+        return self.__is_simple_type
+
+    @property
+    def simple_type(self) -> Type:
+        if self.__is_simple_type is False:
+            raise Exception(
+                "The generated model doesn't represent a simple type")
+        return cast(SimpleTypeInput, self.root).primitive_type
+
+    @singledispatchmethod
+    def __generate_pydantic_model(self, schema, model_name: str) -> PydanticModelType:
+        raise NotImplementedError(
+            f"No overloaded method defined for {type(schema)}")
+
+    @__generate_pydantic_model.register(SimpleTypeInput)
+    def _(self, schema: SimpleTypeInput, model_name: str) -> PydanticModelType:
+        schema_type = schema.primitive_type
+        if schema.is_many:
+            schema_type = List[schema_type]
+        if schema.is_optional:
+            schema_type = Optional[schema_type]
+        return RootModel[schema_type]
+
+    @__generate_pydantic_model.register(ComplexTypeInput)
+    def _(self, schema: ComplexTypeInput, model_name: str) -> PydanticModelType:
+        fields = {}
+        config = schema.config
+
+        for key, value in schema.root.items():
+            if key == '__config':
+                continue
+
+            inner_model = self.__generate_pydantic_model(value, key)
+            default_value = (
+                value.default_value if isinstance(value, SimpleTypeInput)
+                else value.config.default_value
+            )
+            is_optional = (
+                value.is_optional if isinstance(value, SimpleTypeInput)
+                else value.config.is_optional
+            )
+
+            fields[key] = (
+                inner_model,
+                ... if not is_optional else default_value
+            )
+
+        created_model = create_model(model_name, **fields)
+
+        if config.is_many:
+            created_model = List[created_model]
+        if config.is_optional:
+            created_model = Optional[created_model]
+
+        created_model = RootModel[created_model]
+
+        return created_model
+
+    def generate_pydantic_model(self, model_name: str) -> PydanticModelType:
+        if self.__pydantic_model is None:
+            created_model = self.__generate_pydantic_model(
+                self.root, model_name)
+            self.__pydantic_model = created_model
+        return self.__pydantic_model
+
+    @staticmethod
+    def __json_schema_parse_default_values(value: Any) -> Any:
+        value = value() if callable(value) else value
+
+        is_list = isinstance(value, list)
+        values = value if is_list else [value]
+
+        if values and isinstance(values[0], (datetime, UUID)):
+            values = [
+                str(entry)
+                for entry in values
+            ]
+
+        if is_list:
+            return values
+
+        return values[0]
+
+    @staticmethod
+    def __generate_json_schema_from_data_type(
+            primitive_type: Type,
+            description: str = "",
+            field_default_value: Any = None
+    ) -> Dict[str, Any]:
+
+        config = {
+            "field_type": None,
+            "is_many": False,
+            "is_optional": False,
+            "description": description,
+            "field_default_value": field_default_value
+        }
+
+        is_primitive_type_nested = True
+        while is_primitive_type_nested:
+            typing_wrapper = get_origin(primitive_type)
+            if typing_wrapper:
+                is_primitive_type_nested = True
+                if typing_wrapper == Union:
+                    config["is_optional"] = True
+                elif typing_wrapper == list:
+                    config["is_many"] = True
+                primitive_type = get_args(primitive_type)[0]
+            else:
+                is_primitive_type_nested = False
+        try:
+            simple_data_type = PRIMITIVE_TO_DATA_TYPE_LOOKUP.get(
+                primitive_type)
+        except Exception:
+            simple_data_type = None
+
+        # Simple types.
+        if simple_data_type:
+            config["field_type"] = simple_data_type.value
+
+        # Complex types.
+        else:
+            config["field_type"] = DataType.JSON.value
+            config = {
+                "__config": config
+            }
+            for key, value in primitive_type.__fields__.items():
+                config[key] = JsonSchemaParser.__generate_json_schema_from_data_type(
+                    value.annotation,
+                    value.description,
+                    None if value.default == PydanticUndefined else
+                    JsonSchemaParser.__json_schema_parse_default_values(
+                        value.default)
+                )
+
+        return config
+
+    @staticmethod
+    def generate_json_schema_from_data_type(primitive_type: Type) -> Dict[str, Any]:
+        """
+        Generates a JSON schema representation from a given primitive data type.
+        This function converts a Python primitive type or a Pydantic model into a JSON schema
+        string that describes the data structure and its properties.
+        Args:
+            primitive_type (Type): The primitive type or Pydantic model to convert to JSON schema.
+                Can be a basic Python type (str, int, etc.) or a Pydantic model class.
+        Returns:
+            str: A JSON string representing the schema of the input type, including:
+                - field_type: The base data type
+                - is_many: Boolean indicating if it's a collection
+                - is_optional: Boolean indicating if the field is optional
+                - description: Field description string
+                - field_default_value: Default value if any
+                For Pydantic models, returns nested schema with __config and field definitions.
+        Example:
+            >>> generate_json_schema_from_data_type(str)
+            {
+                "field_type": "STRING",
+                "is_many": false,
+                "is_optional": false,
+                "description": "",
+                "field_default_value": null
+            }
+        """
+        return JsonSchemaParser.__generate_json_schema_from_data_type(primitive_type)
+
+    def is_empty(self) -> bool:
+        """Checks if the JSON schema represents an empty structure (i.e., no fields defined).
+        """
+        if self.is_simple_type:
+            return False
+        else:
+            complex_root = cast(ComplexTypeInput, self.root)
+            return complex_root.root == {}

json_schema_parser-1.0.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: json-schema-parser
+Version: 1.0.0
+Summary: Convert between JSON schema definitions and Pydantic models
+Home-page: https://github.com/24torky/json-schema-parser
+Author: Abdelrahman Torky
+Author-email: 24torky@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# json-schema-parser
+
+A Python library for converting between JSON schema definitions and Pydantic models.
+
+## Features
+
+- Parse a JSON schema dict into a validated Pydantic model
+- Generate a JSON schema dict from any Python type or Pydantic model
+- Supports all common types: `integer`, `float`, `string`, `boolean`, `json`, `uuid`, `datetime`
+- Supports list (`is_many`) and optional (`is_optional`) variants of every type
+- Nested object schemas via `ComplexTypeInput`
+
+## Installation
+
+```bash
+pip install json-schema-parser
+```
+
+## Usage
+
+### Parse a JSON schema into a Pydantic model
+
+```python
+from json_schema_parser import JsonSchemaParser
+
+schema = {
+    "__config": {"field_type": "json", "is_many": False, "is_optional": False, "field_default_value": None, "description": ""},
+    "name": {"field_type": "string", "is_many": False, "is_optional": False, "field_default_value": None, "description": "User name"},
+    "age":  {"field_type": "integer", "is_many": False, "is_optional": True, "field_default_value": None, "description": "User age"},
+}
+
+parser = JsonSchemaParser.model_validate(schema)
+Model = parser.generate_pydantic_model("User")
+
+user = Model.model_validate({"name": "Alice", "age": 30})
+```
+
+### Generate a JSON schema from a Python type
+
+```python
+from json_schema_parser import JsonSchemaParser
+from pydantic import BaseModel
+from typing import Optional, List
+
+class Address(BaseModel):
+    street: str
+    city: str
+
+schema = JsonSchemaParser.generate_json_schema_from_data_type(Address)
+```
+
+## Supported field types
+
+| `field_type` value | Python type |
+|---|---|
+| `"integer"` | `int` |
+| `"float"` | `float` |
+| `"string"` | `str` |
+| `"boolean"` | `bool` |
+| `"uuid"` | `UUID` |
+| `"datetime"` | `datetime` |
+| `"json"` | `dict` / nested model |
+
+Set `is_many: true` to get a `List[T]`, and `is_optional: true` to get `Optional[T]`.
+
+## License
+
+MIT

json_schema_parser-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+json_schema_parser/__init__.py,sha256=BABFpUI-WpEua__7fae6X9npFsiqgstdj_lFgIY7yGQ,52
+json_schema_parser/data_types.py,sha256=ET8RxWVJlZt6zRivouKyZ95MHLXmoIUVm5uf4oOWQ5A,4796
+json_schema_parser/src.py,sha256=HGsCfXVBfANcUr00WtbdEKKcU4K2VAbLBGphhmp7Vac,12065
+json_schema_parser-1.0.0.dist-info/licenses/LICENSE,sha256=o2VYQtToy1kCZ5AHF1J_iOhbUUaAfdr2kGIBPcf51Hk,1074
+json_schema_parser-1.0.0.dist-info/METADATA,sha256=QhwqtG294eXP6RONmEFkvTdx1KQac4U0VtsidlLkm2c,2915
+json_schema_parser-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+json_schema_parser-1.0.0.dist-info/top_level.txt,sha256=MepYz5aBi7-J0Xvb5Iv_-QPeUXdCZJOd7myKGS-Bz18,19
+json_schema_parser-1.0.0.dist-info/RECORD,,

json_schema_parser-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

json_schema_parser-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdelrahman Torky
+
+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.

json_schema_parser-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+json_schema_parser