pydantic-avro 0.9.2__tar.gz → 0.10.0__tar.gz

{pydantic_avro-0.9.2 → pydantic_avro-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pydantic-avro
-Version: 0.9.2
+Version: 0.10.0
 Summary: Converting pydantic classes to avro schemas
 Home-page: https://github.com/godatadriven/pydantic-avro
 License: MIT

{pydantic_avro-0.9.2 → pydantic_avro-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pydantic-avro"
-version = "0.9.2"
+version = "0.10.0"
 description = "Converting pydantic classes to avro schemas"
 authors = ["Peter van 't Hof' <peter.vanthof@godatadriven.com>"]
 

{pydantic_avro-0.9.2 → pydantic_avro-0.10.0}/setup.py

@@ -18,7 +18,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'pydantic-avro',
-    'version': '0.9.2',
+    'version': '0.10.0',
     'description': 'Converting pydantic classes to avro schemas',
     'long_description': '[![Python package](https://github.com/godatadriven/pydantic-avro/actions/workflows/python-package.yml/badge.svg)](https://github.com/godatadriven/pydantic-avro/actions/workflows/python-package.yml)\n[![codecov](https://codecov.io/gh/godatadriven/pydantic-avro/branch/main/graph/badge.svg?token=5L08GOERAW)](https://codecov.io/gh/godatadriven/pydantic-avro)\n[![PyPI version](https://badge.fury.io/py/pydantic-avro.svg)](https://badge.fury.io/py/pydantic-avro)\n[![CodeQL](https://github.com/godatadriven/pydantic-avro/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/godatadriven/pydantic-avro/actions/workflows/codeql-analysis.yml)\n\n# pydantic-avro\n\nThis library can convert a pydantic class to a avro schema or generate python code from a avro schema.\n\n### Install\n\n```bash\npip install pydantic-avro\n```\n\n### Pydantic class to avro schema\n\n```python\nimport json\nfrom typing import Optional\n\nfrom pydantic_avro.base import AvroBase\n\n\nclass TestModel(AvroBase):\n    key1: str\n    key2: int\n    key2: Optional[str]\n\n\nschema_dict: dict = TestModel.avro_schema()\nprint(json.dumps(schema_dict))\n\n```\n\n### Avro schema to pydantic\n\n```shell\n# Print to stdout\npydantic-avro avro_to_pydantic --asvc /path/to/schema.asvc\n\n# Save it to a file\npydantic-avro avro_to_pydantic --asvc /path/to/schema.asvc --output /path/to/output.py\n```\n\n### Specify expected Avro type\n\n```python\nfrom datetime import datetime\nfrom pydantic import Field\nfrom pydantic_avro.base import AvroBase \n\nclass ExampleModel(AvroBase):\n    field1: int = Field(..., avro_type="long")  # Explicitly set Avro type to "long"\n    field2: datetime = Field(..., avro_type="timestamp-millis")  # Explicitly set Avro type to "timestamp-millis"\n```\n\n### Install for developers\n\n###### Install package\n\n- Requirement: Poetry 1.*\n\n```shell\npoetry install\n```\n\n###### Run unit tests\n```shell\npytest\ncoverage run -m pytest  # with coverage\n# or (depends on your local env) \npoetry run pytest\npoetry run coverage run -m pytest  # with coverage\n```\n\n##### Run linting\n\nThe linting is checked in the github workflow. To fix and review issues run this:\n```shell\nblack .   # Auto fix all issues\nisort .   # Auto fix all issues\npflake .  # Only display issues, fixing is manual\n```\n',
     'author': "Peter van 't Hof'",

pydantic_avro-0.10.0/src/pydantic_avro/__init__.py

@@ -0,0 +1,3 @@
+from pydantic_avro.to_avro.base import AvroBase as AvroBase
+
+__all__ = ["AvroBase"]

{pydantic_avro-0.9.2 → pydantic_avro-0.10.0}/src/pydantic_avro/to_avro/base.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Literal, Optional
 
 from pydantic import BaseModel
 
@@ -10,14 +10,30 @@ class AvroBase(BaseModel):
     """This class provides functionality to convert a pydantic model to an Avro schema."""
 
     @classmethod
-    def avro_schema(cls, by_alias: bool = True, namespace: Optional[str] = None) -> dict:
+    def avro_schema(
+        cls,
+        by_alias: bool = True,
+        namespace: Optional[str] = None,
+        mode: Literal["validation", "serialization"] = "serialization",
+    ) -> dict:
         """Returns the avro schema for the pydantic class
 
         :param by_alias: generate the schemas using the aliases defined, if any
         :param namespace: Provide an optional namespace string to use in schema generation
+        :param mode: The mode for generating the schema. Use 'validation' for input validation
+                     or 'serialization' for output serialization. Defaults to 'serialization'.
+                     Only applicable for Pydantic v2.
         :return: dict with the Avro Schema for the model
         """
-        schema = cls.model_json_schema(by_alias=by_alias) if PYDANTIC_V2 else cls.schema(by_alias=by_alias)
+        if PYDANTIC_V2:
+            schema = cls.model_json_schema(by_alias=by_alias, mode=mode)
+        else:
+            if mode != "serialization":
+                raise ValueError(
+                    f"The 'mode' parameter is only supported in Pydantic v2. "
+                    f"Pydantic v1 does not support different schema modes."
+                )
+            schema = cls.schema(by_alias=by_alias)
 
         if namespace is None:
             # Default namespace will be based on title

{pydantic_avro-0.9.2 → pydantic_avro-0.10.0}/src/pydantic_avro/to_avro/types.py

@@ -1,3 +1,4 @@
+from copy import deepcopy
 from typing import Any, Dict, List, Optional, Set
 
 from pydantic_avro.to_avro.config import DEFS_NAME
@@ -133,6 +134,13 @@ class AvroTypeConverter:
         f = field_props.get("format")
         r = field_props.get("$ref")
         at = field_props.get("avro_type")
+        
+        # For Pydantic v1, check json_schema_extra for avro_type
+        if at is None and "json_schema_extra" in field_props:
+            json_schema_extra = field_props.get("json_schema_extra")
+            if isinstance(json_schema_extra, dict):
+                at = json_schema_extra.get("avro_type")
+        
         if "allOf" in field_props and len(field_props["allOf"]) == 1:
             r = field_props["allOf"][0]["$ref"]
         if ("prefixItems" in field_props or ("minItems" in field_props and "maxItems" in field_props)) and t == "array":
@@ -142,9 +150,9 @@ class AvroTypeConverter:
         discriminator = field_props.get("discriminator")
 
         if u is not None:
-            return self._union_to_avro(u, avro_type_dict, discriminator)
+            return self._union_to_avro(u, avro_type_dict, discriminator, parent_avro_type=at)
         elif o is not None:
-            return self._union_to_avro(o, avro_type_dict, discriminator)
+            return self._union_to_avro(o, avro_type_dict, discriminator, parent_avro_type=at)
         elif r is not None:
             return self._handle_references(r, avro_type_dict)
         elif t is None:
@@ -232,15 +240,37 @@ class AvroTypeConverter:
             value_type = self._get_avro_type_dict(a)["type"]
         return {"type": "map", "values": value_type}
 
-    def _union_to_avro(self, field_props: list, avro_type_dict: dict, discriminator: Optional[dict] = None) -> dict:
+    def _should_propagate_avro_type(self, union_element: dict, parent_avro_type: str) -> bool:
+        """Determine if parent avro_type should be propagated to this union element"""
+        # Don't propagate to null types or elements that already have avro_type
+        if union_element.get("type") == "null" or "avro_type" in union_element:
+            return False
+        
+        element_format = union_element.get("format")
+        
+        # Only propagate temporal avro_types to date-time formatted elements
+        temporal_avro_types = {"timestamp-millis", "timestamp-micros", "time-millis", "time-micros", "date"}
+        if parent_avro_type in temporal_avro_types:
+            return element_format in {"date-time", "date", "time"}
+        
+        # For other avro_types, only propagate if there's no format (meaning it's not already specialized)
+        return element_format is None
+
+    def _union_to_avro(self, field_props: list, avro_type_dict: dict, discriminator: Optional[dict] = None, parent_avro_type: Optional[str] = None) -> dict:
         """Returns a type of a union field, including discriminated unions"""
         # Handle discriminated unions
         if discriminator is not None:
             return self._discriminated_union_to_avro(field_props, avro_type_dict, discriminator)
 
-        # Standard union handling (unchanged)
+        # Standard union handling
         avro_type_dict["type"] = []
         for union_element in field_props:
+            # Propagate parent avro_type to compatible union elements
+            if parent_avro_type is not None and self._should_propagate_avro_type(union_element, parent_avro_type):
+                # Create a deep copy to avoid modifying the original
+                union_element = deepcopy(union_element)
+                union_element["avro_type"] = parent_avro_type
+            
             t = self._get_avro_type_dict(union_element)
             avro_type_dict["type"].append(t["type"])
         return avro_type_dict

pydantic_avro-0.9.2/src/pydantic_avro/__init__.py

@@ -1 +0,0 @@
-from pydantic_avro.to_avro.base import AvroBase