pydantic-avro 0.6.5__py3-none-any.whl → 0.7.0__py3-none-any.whl

pydantic_avro/__init__.py

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

pydantic_avro/__main__.py

@@ -2,7 +2,7 @@ import argparse
 import sys
 from typing import List
 
-from pydantic_avro.avro_to_pydantic import convert_file
+from pydantic_avro.from_avro.avro_to_pydantic import convert_file
 
 
 def main(input_args: List[str]):

pydantic_avro/base.py

@@ -1,187 +1,2 @@
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel
-from pydantic.version import VERSION as PYDANTIC_VERSION
-
-PYDANTIC_V2 = PYDANTIC_VERSION.startswith("2.")
-
-DEFS_NAME = "$defs" if PYDANTIC_V2 else "definitions"
-
-
-class AvroBase(BaseModel):
-    """This is base pydantic class that will add some methods"""
-
-    @classmethod
-    def avro_schema(cls, by_alias: bool = True, namespace: Optional[str] = None) -> dict:
-        """
-        Return 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
-        :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 namespace is None:
-            # default namespace will be based on title
-            namespace = schema["title"]
-
-        return cls._avro_schema(schema, namespace)
-
-    @staticmethod
-    def _avro_schema(schema: dict, namespace: str) -> dict:
-        """Return the avro schema for the given pydantic schema"""
-
-        classes_seen = set()
-
-        def get_definition(ref: str, schema: dict):
-            """Reading definition of base schema for nested structs"""
-            id = ref.replace(f"#/{DEFS_NAME}/", "")
-            d = schema.get(DEFS_NAME, {}).get(id)
-            if d is None:
-                raise RuntimeError(f"Definition {id} does not exist")
-            return d
-
-        def get_type(value: dict) -> dict:
-            """Returns a type of a single field"""
-            t = value.get("type")
-            f = value.get("format")
-            r = value.get("$ref")
-            a = value.get("additionalProperties")
-            u = value.get("anyOf")
-            minimum = value.get("minimum")
-            maximum = value.get("maximum")
-            avro_type_dict: Dict[str, Any] = {}
-            if "default" in value:
-                avro_type_dict["default"] = value.get("default")
-            if "description" in value:
-                avro_type_dict["doc"] = value.get("description")
-            if "allOf" in value and len(value["allOf"]) == 1:
-                r = value["allOf"][0]["$ref"]
-            if u is not None:
-                avro_type_dict["type"] = []
-                for union_element in u:
-                    avro_type_dict["type"].append(get_type(union_element)["type"])
-            elif r is not None:
-                class_name = r.replace(f"#/{DEFS_NAME}/", "")
-                if class_name in classes_seen:
-                    avro_type_dict["type"] = class_name
-                else:
-                    d = get_definition(r, schema)
-                    if "enum" in d:
-                        avro_type_dict["type"] = {
-                            "type": "enum",
-                            "symbols": [str(v) for v in d["enum"]],
-                            "name": d["title"],
-                        }
-                    else:
-                        avro_type_dict["type"] = {
-                            "type": "record",
-                            "fields": get_fields(d),
-                            # Name of the struct should be unique true the complete schema
-                            # Because of this the path in the schema is tracked and used as name for a nested struct/array
-                            "name": class_name,
-                        }
-
-                    classes_seen.add(class_name)
-            elif t == "array":
-                items = value.get("items")
-                tn = get_type(items)
-                # If items in array are a object:
-                if "$ref" in items:
-                    tn = tn["type"]
-                # If items in array are a logicalType
-                if (
-                    isinstance(tn, dict)
-                    and isinstance(tn.get("type", {}), dict)
-                    and tn.get("type", {}).get("logicalType") is not None
-                ):
-                    tn = tn["type"]
-                # If items in array are an array, the structure must be corrected
-                if (
-                    isinstance(tn, dict)
-                    and isinstance(tn.get("type", {}), dict)
-                    and tn.get("type", {}).get("type") == "array"
-                ):
-                    items = tn["type"]["items"]
-                    tn = {"type": "array", "items": items}
-                avro_type_dict["type"] = {"type": "array", "items": tn}
-            elif t == "string" and f == "date-time":
-                avro_type_dict["type"] = {
-                    "type": "long",
-                    "logicalType": "timestamp-micros",
-                }
-            elif t == "string" and f == "date":
-                avro_type_dict["type"] = {
-                    "type": "int",
-                    "logicalType": "date",
-                }
-            elif t == "string" and f == "time":
-                avro_type_dict["type"] = {
-                    "type": "long",
-                    "logicalType": "time-micros",
-                }
-            elif t == "string" and f == "uuid":
-                avro_type_dict["type"] = {
-                    "type": "string",
-                    "logicalType": "uuid",
-                }
-            elif t == "string" and f == "binary":
-                avro_type_dict["type"] = "bytes"
-            elif t == "string":
-                avro_type_dict["type"] = "string"
-            elif t == "number":
-                avro_type_dict["type"] = "double"
-            elif t == "integer":
-                # integer in python can be a long, only if minimum and maximum value is set a int can be used
-                if minimum is not None and minimum >= -(2**31) and maximum is not None and maximum <= (2**31 - 1):
-                    avro_type_dict["type"] = "int"
-                else:
-                    avro_type_dict["type"] = "long"
-            elif t == "boolean":
-                avro_type_dict["type"] = "boolean"
-            elif t == "null":
-                avro_type_dict["type"] = "null"
-            elif t == "object":
-                if a is None:
-                    value_type = "string"
-                else:
-                    value_type = get_type(a)
-                if isinstance(value_type, dict) and len(value_type) == 1:
-                    value_type = value_type.get("type")
-                avro_type_dict["type"] = {"type": "map", "values": value_type}
-            else:
-                raise NotImplementedError(
-                    f"Type '{t}' not support yet, "
-                    f"please report this at https://github.com/godatadriven/pydantic-avro/issues"
-                )
-            return avro_type_dict
-
-        def get_fields(s: dict) -> List[dict]:
-            """Return a list of fields of a struct"""
-            fields = []
-
-            required = s.get("required", [])
-            for key, value in s.get("properties", {}).items():
-                avro_type_dict = get_type(value)
-                avro_type_dict["name"] = key
-
-                if key not in required:
-                    if type(avro_type_dict["type"]) is list:
-                        if "null" not in avro_type_dict["type"]:
-                            avro_type_dict["type"].insert(0, "null")
-                    elif avro_type_dict.get("default") is None:
-                        avro_type_dict["type"] = ["null", avro_type_dict["type"]]
-                    avro_type_dict.setdefault("default", None)
-
-                # null must be the first element in the list
-                if type(avro_type_dict["type"]) is list and "null" in avro_type_dict["type"]:
-                    avro_type_dict["type"].remove("null")
-                    avro_type_dict["type"].insert(0, "null")
-
-                fields.append(avro_type_dict)
-            return fields
-
-        fields = get_fields(schema)
-
-        return {"type": "record", "namespace": namespace, "name": schema["title"], "fields": fields}
+# For backwards compatability
+from pydantic_avro.to_avro.base import AvroBase

pydantic_avro/from_avro/avro_to_pydantic.py

@@ -0,0 +1,48 @@
+import json
+from typing import Optional
+
+from pydantic_avro.from_avro.class_registery import ClassRegistry
+from pydantic_avro.from_avro.types import get_pydantic_type
+
+
+def validate_schema(schema: dict) -> None:
+    if "type" not in schema:
+        raise AttributeError("Type not supported")
+    if "name" not in schema:
+        raise AttributeError("Name is required")
+    if "fields" not in schema:
+        raise AttributeError("Fields are required")
+
+
+def avsc_to_pydantic(schema: dict) -> str:
+    """Generate python code of pydantic of given Avro Schema"""
+    # Ensures that state is clean from previous calls
+    ClassRegistry().clear()
+    validate_schema(schema)
+    get_pydantic_type(schema)
+
+    file_content = """
+from datetime import date, datetime, time
+from decimal import Decimal
+from enum import Enum
+from typing import List, Optional, Dict, Union
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+"""
+    file_content += "\n\n".join(ClassRegistry().classes.values())
+
+    return file_content
+
+
+def convert_file(avsc_path: str, output_path: Optional[str] = None):
+    with open(avsc_path, "r") as fh:
+        avsc_dict = json.load(fh)
+    file_content = avsc_to_pydantic(avsc_dict)
+    if output_path is None:
+        print(file_content)
+    else:
+        with open(output_path, "w") as fh:
+            fh.write(file_content)

pydantic_avro/from_avro/class_registery.py

@@ -0,0 +1,29 @@
+class ClassRegistry:
+    """Singleton class to store generated Pydantic classes."""
+
+    _instance = None
+    _classes: dict = {}
+
+    def __new__(cls):
+        """Singleton implementation."""
+        if cls._instance is None:
+            cls._instance = super(ClassRegistry, cls).__new__(cls)
+            cls._instance._classes = {}
+        return cls._instance
+
+    def add_class(self, name: str, class_def: str):
+        """Add a class to the registry."""
+        self._classes[name] = class_def
+
+    @property
+    def classes(self) -> dict:
+        """Get all classes in the registry."""
+        return self._classes
+
+    def has_class(self, name: str) -> bool:
+        """Check if a class is in the registry."""
+        return name in self._classes.keys()
+
+    def clear(self):
+        """Clear all classes from the registry."""
+        self._classes.clear()

pydantic_avro/from_avro/types.py

@@ -0,0 +1,149 @@
+import json
+from typing import Callable, Union
+
+from pydantic_avro.from_avro.class_registery import ClassRegistry
+
+LOGICAL_TYPES = {
+    "uuid": "UUID",
+    "decimal": "Decimal",
+    "timestamp-millis": "datetime",
+    "timestamp-micros": "datetime",
+    "time-millis": "time",
+    "time-micros": "time",
+    "date": "date",
+}
+
+
+AVRO_TO_PY_MAPPING = {
+    "string": "str",
+    "int": "int",
+    "long": "int",
+    "boolean": "bool",
+    "double": "float",
+    "float": "float",
+    "bytes": "bytes",
+}
+
+
+def list_type_handler(t: dict) -> str:
+    """Get the Python type of a given Avro list type"""
+    l = t["type"]
+    if "null" in l and len(l) == 2:
+        c = l.copy()
+        c.remove("null")
+        return f"Optional[{get_pydantic_type(c[0])}]"
+    if "null" in l:
+        return f"Optional[Union[{','.join([get_pydantic_type(e) for e in l if e != 'null'])}]]"
+    return f"Union[{','.join([get_pydantic_type(e) for e in l])}]"
+
+
+def map_type_handler(t: dict) -> str:
+    """Get the Python type of a given Avro map type"""
+
+    avro_value_type = t["type"].get("values")
+
+    if avro_value_type is None:
+        raise AttributeError("Values are required for map type")
+
+    value_type = get_pydantic_type(avro_value_type)
+    return f"Dict[str, {value_type}]"
+
+
+def logical_type_handler(t: dict) -> str:
+    """Get the Python type of a given Avro logical type"""
+    return LOGICAL_TYPES[t["type"]["logicalType"]]
+
+
+def enum_type_handler(t: dict) -> str:
+    """Gets the enum type of a given Avro enum type and adds it to the class registry"""
+    name = t["type"].get("name")
+    if not ClassRegistry().has_class(name):
+        enum_class = f"class {name}(str, Enum):\n"
+        for s in t["type"].get("symbols"):
+            enum_class += f'    {s} = "{s}"\n'
+        ClassRegistry().add_class(name, enum_class)
+    return name
+
+
+def array_type_handler(t: dict) -> str:
+    """Get the Python type of a given Avro array type"""
+    if isinstance(t["type"], dict):
+        sub_type = get_pydantic_type(t["type"]["items"])
+    else:
+        sub_type = get_pydantic_type(t["items"])
+    return f"List[{sub_type}]"
+
+
+def record_type_handler(t: dict) -> str:
+    """Gets the record type of a given Avro record type and adds it to the class registry"""
+    t = t["type"] if isinstance(t["type"], dict) else t
+    name = t["name"]
+    fields = t["fields"] if "fields" in t else t["type"]["fields"]
+    field_strings = [generate_field_string(field) for field in fields]
+    class_body = "\n".join(field_strings) if field_strings else "    pass"
+    current = f"class {name}(BaseModel):\n{class_body}\n"
+    ClassRegistry().add_class(name, current)
+    return name
+
+
+TYPE_HANDLERS = {
+    "list": list_type_handler,
+    "map": map_type_handler,
+    "logical": logical_type_handler,
+    "enum": enum_type_handler,
+    "array": array_type_handler,
+    "record": record_type_handler,
+}
+
+
+def generate_field_string(field: dict) -> str:
+    """Generate a string representing a field in the Pydantic model."""
+    n = field["name"]
+    t = get_pydantic_type(field)
+    default = field.get("default")
+    if field["type"] == "int" and "default" in field and isinstance(default, (bool, type(None))):
+        return f"    {n}: {t} = Field({default}, ge=-2**31, le=(2**31 - 1))"
+    elif field["type"] == "int" and "default" in field:
+        return f"    {n}: {t} = Field({json.dumps(default)}, ge=-2**31, le=(2**31 - 1))"
+    elif field["type"] == "int":
+        return f"    {n}: {t} = Field(..., ge=-2**31, le=(2**31 - 1))"
+    elif "default" not in field:
+        return f"    {n}: {t}"
+    elif isinstance(default, (bool, type(None))):
+        return f"    {n}: {t} = {default}"
+    else:
+        return f"    {n}: {t} = {json.dumps(default)}"
+
+
+def get_pydantic_type(t: Union[str, dict]) -> str:
+    """Get the Pydantic type for a given Avro type"""
+    if isinstance(t, str):
+        t = {"type": t}
+
+    if isinstance(t["type"], str):
+        if ClassRegistry().has_class(t["type"]):
+            return t["type"]
+
+        if t["type"] in AVRO_TO_PY_MAPPING:
+            return AVRO_TO_PY_MAPPING[t["type"]]
+
+    return get_type_handler(t)(t)
+
+
+def get_type_handler(t: dict) -> Callable:
+    """Get the handler for a given Avro type"""
+    h = None
+    t = t["type"]
+    if isinstance(t, str):
+        h = TYPE_HANDLERS.get(t)
+    elif isinstance(t, dict) and "logicalType" in t:
+        h = TYPE_HANDLERS.get("logical")
+    elif isinstance(t, dict) and "type" in t:
+        h = TYPE_HANDLERS.get(t["type"])
+    elif isinstance(t, list):
+        h = TYPE_HANDLERS.get("list")
+
+    if h:
+        return h
+
+    raise NotImplementedError(f"Type {t} not supported yet")

pydantic_avro/to_avro/base.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+from pydantic_avro.to_avro.config import PYDANTIC_V2
+from pydantic_avro.to_avro.types import AvroTypeConverter
+
+
+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:
+        """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
+        :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 namespace is None:
+            # Default namespace will be based on title
+            namespace = schema["title"]
+
+        avro_type_handler = AvroTypeConverter(schema)
+
+        return cls._avro_schema(schema, namespace, avro_type_handler)
+
+    @staticmethod
+    def _avro_schema(schema: dict, namespace: str, avro_type_handler: AvroTypeConverter) -> dict:
+        """Return the avro schema for the given pydantic schema"""
+
+        fields = avro_type_handler.fields_to_avro_dicts(schema)
+        return {"type": "record", "namespace": namespace, "name": schema["title"], "fields": fields}

pydantic_avro/to_avro/config.py

@@ -0,0 +1,4 @@
+from pydantic import VERSION as PYDANTIC_VERSION
+
+PYDANTIC_V2 = PYDANTIC_VERSION.startswith("2.")
+DEFS_NAME = "$defs" if PYDANTIC_V2 else "definitions"

pydantic_avro/to_avro/types.py

@@ -0,0 +1,202 @@
+from typing import Any, Dict, List, Optional, Set
+
+from pydantic_avro.to_avro.config import DEFS_NAME
+
+STRING_TYPE_MAPPING = {
+    "date-time": {
+        "type": "long",
+        "logicalType": "timestamp-micros",
+    },
+    "date": {
+        "type": "int",
+        "logicalType": "date",
+    },
+    "time": {
+        "type": "long",
+        "logicalType": "time-micros",
+    },
+    "uuid": {
+        "type": "string",
+        "logicalType": "uuid",
+    },
+    "binary": "bytes",
+}
+
+
+def get_definition(ref: str, schema: dict):
+    """Reading definition of base schema for nested structs"""
+    id = ref.replace(f"#/{DEFS_NAME}/", "")
+    d = schema.get(DEFS_NAME, {}).get(id)
+    if d is None:
+        raise RuntimeError(f"Definition {id} does not exist")
+    return d
+
+
+def set_nullability(avro_type_dict: dict) -> dict:
+    """Set the nullability of the field"""
+    if type(avro_type_dict["type"]) is list:
+        if "null" not in avro_type_dict["type"]:
+            avro_type_dict["type"].insert(0, "null")
+    elif avro_type_dict.get("default") is None:
+        avro_type_dict["type"] = ["null", avro_type_dict["type"]]
+    avro_type_dict.setdefault("default", None)
+    return avro_type_dict
+
+
+def null_to_first_element(avro_type_dict: dict) -> dict:
+    """Set the null as the first element in the list as per avro schema requirements"""
+    if type(avro_type_dict["type"]) is list and "null" in avro_type_dict["type"]:
+        avro_type_dict["type"].remove("null")
+        avro_type_dict["type"].insert(0, "null")
+    return avro_type_dict
+
+
+class AvroTypeConverter:
+    """Converts Pydantic schema to AVRO schema."""
+
+    def __init__(self, schema: dict):
+        self.root_schema = schema
+        self.classes_seen: Set[str] = set()
+
+    def fields_to_avro_dicts(self, parent_schema: dict) -> List[dict]:
+        """Converts fields from the schema to AVRO and returns them as a list of dictionaries.
+
+        :param parent_schema: The parent schema of the field (not the root schema for nested models)
+        """
+        fields = []
+
+        required = parent_schema.get("required", [])
+        for name, field_props in parent_schema.get("properties", {}).items():
+            avro_type_dict = self._get_avro_type_dict(field_props=field_props)
+            avro_type_dict["name"] = name
+            if name not in required:
+                set_nullability(avro_type_dict)
+                avro_type_dict = null_to_first_element(avro_type_dict)
+
+            fields.append(avro_type_dict)
+        return fields
+
+    def _get_avro_type_dict(self, field_props: dict) -> dict:
+        """Returns a type of a single field"""
+        avro_type_dict: Dict[str, Any] = {}
+        if "default" in field_props:
+            avro_type_dict["default"] = field_props.get("default")
+        if "description" in field_props:
+            avro_type_dict["doc"] = field_props.get("description")
+        avro_type_dict = self._get_avro_type(field_props, avro_type_dict)
+        return avro_type_dict
+
+    def _get_avro_type(self, field_props: dict, avro_type_dict: dict) -> dict:
+        """Returns AVRO type of a single field"""
+        t = field_props.get("type")
+        f = field_props.get("format")
+        r = field_props.get("$ref")
+        if "allOf" in field_props and len(field_props["allOf"]) == 1:
+            r = field_props["allOf"][0]["$ref"]
+        u = field_props.get("anyOf")
+
+        if u is not None:
+            return self._union_to_avro(u, avro_type_dict)
+        elif r is not None:
+            return self._handle_references(r, avro_type_dict)
+        elif t is None:
+            raise ValueError(f"Field '{field_props}' does not have a defined type.")
+        elif t == "array":
+            return self._array_to_avro(field_props, avro_type_dict)
+        elif t == "string":
+            avro_type_dict["type"] = self._string_to_avro(f)
+        elif t == "integer":
+            avro_type_dict["type"] = self._integer_to_avro(field_props)
+        elif t == "object":
+            avro_type_dict["type"] = self._object_to_avro(field_props)
+        elif t == "number":
+            avro_type_dict["type"] = "double"
+        elif t == "boolean":
+            avro_type_dict["type"] = "boolean"
+        elif t == "null":
+            avro_type_dict["type"] = "null"
+        else:
+            raise NotImplementedError(
+                f"Type '{t}' not support yet, "
+                f"please report this at https://github.com/godatadriven/pydantic-avro/issues"
+            )
+
+        return avro_type_dict
+
+    def _handle_references(self, r: str, avro_type_dict: dict) -> dict:
+        """Finds the type of a reference field"""
+        class_name = r.replace(f"#/{DEFS_NAME}/", "")
+        if class_name in self.classes_seen:
+            avro_type_dict["type"] = class_name
+            return avro_type_dict
+
+        d = get_definition(r, self.root_schema)
+        if "enum" in d:
+            avro_type_dict["type"] = {
+                "type": "enum",
+                "symbols": [str(v) for v in d["enum"]],
+                "name": d["title"],
+            }
+        else:
+            avro_type_dict["type"] = {
+                "type": "record",
+                "fields": self.fields_to_avro_dicts(d),
+                # Name of the struct should be unique to the complete schema
+                # Because of this the path in the schema is tracked and used as name for a nested struct/array
+                "name": class_name,
+            }
+
+        self.classes_seen.add(class_name)
+        return avro_type_dict
+
+    @staticmethod
+    def _string_to_avro(f: Optional[str]):
+        """Returns a type of a string field"""
+        if not f:
+            return "string"
+        return STRING_TYPE_MAPPING[f]
+
+    @staticmethod
+    def _integer_to_avro(field_props: dict) -> str:
+        """Returns a type of an integer field"""
+        minimum = field_props.get("minimum")
+        maximum = field_props.get("maximum")
+        # integer in python can be a long, only if minimum and maximum value is set an int can be used
+        if minimum is not None and minimum >= -(2**31) and maximum is not None and maximum <= (2**31 - 1):
+            return "int"
+        return "long"
+
+    def _object_to_avro(self, field_props: dict) -> dict:
+        """Returns a type of an object field"""
+        a = field_props.get("additionalProperties")
+        value_type = "string" if a is None else 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) -> dict:
+        """Returns a type of a union field"""
+        avro_type_dict["type"] = []
+        for union_element in field_props:
+            t = self._get_avro_type_dict(union_element)
+            avro_type_dict["type"].append(t["type"])
+        return avro_type_dict
+
+    def _array_to_avro(self, field_props: dict, avro_type_dict: dict) -> dict:
+        """Returns a type of an array field"""
+        items = field_props["items"]
+        tn = self._get_avro_type_dict(items)
+        # If items in array are an object:
+        if "$ref" in items:
+            tn = tn["type"]
+        # If items in array are a logicalType
+        if (
+            isinstance(tn, dict)
+            and isinstance(tn.get("type", {}), dict)
+            and tn.get("type", {}).get("logicalType") is not None
+        ):
+            tn = tn["type"]
+        # If items in array are an array, the structure must be corrected
+        if isinstance(tn, dict) and isinstance(tn.get("type", {}), dict) and tn.get("type", {}).get("type") == "array":
+            items = tn["type"]["items"]
+            tn = {"type": "array", "items": items}
+        avro_type_dict["type"] = {"type": "array", "items": tn}
+        return avro_type_dict

{pydantic_avro-0.6.5.dist-info → pydantic_avro-0.7.0.dist-info}/METADATA

@@ -1,17 +1,15 @@
 Metadata-Version: 2.1
 Name: pydantic-avro
-Version: 0.6.5
+Version: 0.7.0
 Summary: Converting pydantic classes to avro schemas
 Home-page: https://github.com/godatadriven/pydantic-avro
 License: MIT
 Keywords: pydantic,avro
 Author: Peter van 't Hof'
 Author-email: peter.vanthof@godatadriven.com
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.8.1,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -42,11 +40,13 @@ from typing import Optional
 
 from pydantic_avro.base import AvroBase
 
+
 class TestModel(AvroBase):
     key1: str
     key2: int
     key2: Optional[str]
 
+
 schema_dict: dict = TestModel.avro_schema()
 print(json.dumps(schema_dict))
 

pydantic_avro-0.7.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+LICENSE,sha256=gBlYCG1yxb0vGlsmek0lMPVOK5YDxQope4F54jzeqoY,1069
+pydantic_avro/__init__.py,sha256=P4vaozEL8Rea7xWdB6ENj3DNF2RPPOWascfwbtQS7gE,48
+pydantic_avro/__main__.py,sha256=-AL9FNYsAdFmilm-96MbbxymTW6QminXPCBZJ1nkqBE,695
+pydantic_avro/base.py,sha256=i1wco_T6FXFdtlxzbzXt3Jv93TmTzTfJ493KCfZh1dc,78
+pydantic_avro/from_avro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_avro/from_avro/avro_to_pydantic.py,sha256=FOEd_6TqoHSlLALgyveb456B3f7TEPGw2ByRgRcigqc,1356
+pydantic_avro/from_avro/class_registery.py,sha256=n_8yELp-Eux9bAs4CJOV78bQ061VV_-2FuvowOQpWCg,864
+pydantic_avro/from_avro/types.py,sha256=yMpUXHr-06VQwECr3zwVITy9RzNbtVrs7oNbcXYQF7M,4663
+pydantic_avro/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_avro/to_avro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_avro/to_avro/base.py,sha256=Y8QOGTpXO3BwJ6arrRK-k2JniK5kLTvlDpQ0PyZojmg,1409
+pydantic_avro/to_avro/config.py,sha256=R9HLkWiXs7YZ02te8CQt5Kf2rbsE8Fx-hjqv3tBSFJU,152
+pydantic_avro/to_avro/types.py,sha256=gY-4ay0IF1dDIxtVsLyzH-AkzcE_dHpnyCrd00cj3TE,7755
+pydantic_avro-0.7.0.dist-info/entry_points.txt,sha256=gwHiQfbGLO8Np2sa1bZ_bpxU7sEufx6IachViBE_Fnw,66
+pydantic_avro-0.7.0.dist-info/LICENSE,sha256=gBlYCG1yxb0vGlsmek0lMPVOK5YDxQope4F54jzeqoY,1069
+pydantic_avro-0.7.0.dist-info/WHEEL,sha256=vxFmldFsRN_Hx10GDvsdv1wroKq8r5Lzvjp6GZ4OO8c,88
+pydantic_avro-0.7.0.dist-info/METADATA,sha256=pBP-3GaAwFBhqcBu8T5U4uIgbVDE_sd6lmquLABP5jM,2571
+pydantic_avro-0.7.0.dist-info/RECORD,,

pydantic_avro/avro_to_pydantic.py

@@ -1,138 +0,0 @@
-import json
-from typing import Optional, Union
-
-
-def avsc_to_pydantic(schema: dict) -> str:
-    """Generate python code of pydantic of given Avro Schema"""
-    if "type" not in schema or schema["type"] != "record":
-        raise AttributeError("Type not supported")
-    if "name" not in schema:
-        raise AttributeError("Name is required")
-    if "fields" not in schema:
-        raise AttributeError("fields are required")
-
-    classes = {}
-
-    def get_python_type(t: Union[str, dict]) -> str:
-        """Returns python type for given avro type"""
-        optional = False
-        if isinstance(t, str):
-            if t == "string":
-                py_type = "str"
-            elif t == "int":
-                py_type = "int"
-            elif t == "long":
-                py_type = "int"
-            elif t == "boolean":
-                py_type = "bool"
-            elif t == "double" or t == "float":
-                py_type = "float"
-            elif t == "bytes":
-                py_type = "bytes"
-            elif t in classes:
-                py_type = t
-            else:
-                raise NotImplementedError(f"Type {t} not supported yet")
-        elif isinstance(t, list):
-            if "null" in t and len(t) == 2:
-                optional = True
-                c = t.copy()
-                c.remove("null")
-                py_type = get_python_type(c[0])
-            else:
-                if "null" in t:
-                    py_type = f"Optional[Union[{','.join([ get_python_type(e) for e in t if e != 'null'])}]]"
-                else:
-                    py_type = f"Union[{','.join([ get_python_type(e) for e in t])}]"
-        elif t.get("logicalType") == "uuid":
-            py_type = "UUID"
-        elif t.get("logicalType") == "decimal":
-            py_type = "Decimal"
-        elif t.get("logicalType") == "timestamp-millis" or t.get("logicalType") == "timestamp-micros":
-            py_type = "datetime"
-        elif t.get("logicalType") == "time-millis" or t.get("logicalType") == "time-micros":
-            py_type = "time"
-        elif t.get("logicalType") == "date":
-            py_type = "date"
-        elif t.get("type") == "enum":
-            enum_name = t.get("name")
-            if enum_name not in classes:
-                enum_class = f"class {enum_name}(str, Enum):\n"
-                for s in t.get("symbols"):
-                    enum_class += f'    {s} = "{s}"\n'
-                classes[enum_name] = enum_class
-            py_type = enum_name
-        elif t.get("type") == "string":
-            py_type = "str"
-        elif t.get("type") == "array":
-            sub_type = get_python_type(t.get("items"))
-            py_type = f"List[{sub_type}]"
-        elif t.get("type") == "record":
-            record_type_to_pydantic(t)
-            py_type = t.get("name")
-        elif t.get("type") == "map":
-            value_type = get_python_type(t.get("values"))
-            py_type = f"Dict[str, {value_type}]"
-        else:
-            raise NotImplementedError(
-                f"Type {t} not supported yet, "
-                f"please report this at https://github.com/godatadriven/pydantic-avro/issues"
-            )
-        if optional:
-            return f"Optional[{py_type}]"
-        else:
-            return py_type
-
-    def record_type_to_pydantic(schema: dict):
-        """Convert a single avro record type to a pydantic class"""
-        name = schema["name"]
-        current = f"class {name}(BaseModel):\n"
-
-        for field in schema["fields"]:
-            n = field["name"]
-            t = get_python_type(field["type"])
-            default = field.get("default")
-            if field["type"] == "int" and "default" in field and isinstance(default, (bool, type(None))):
-                current += f"    {n}: {t} = Field({default}, ge=-2**31, le=(2**31 - 1))\n"
-            elif field["type"] == "int" and "default" in field:
-                current += f"    {n}: {t} = Field({json.dumps(default)}, ge=-2**31, le=(2**31 - 1))\n"
-            elif field["type"] == "int":
-                current += f"    {n}: {t} = Field(..., ge=-2**31, le=(2**31 - 1))\n"
-            elif "default" not in field:
-                current += f"    {n}: {t}\n"
-            elif isinstance(default, (bool, type(None))):
-                current += f"    {n}: {t} = {default}\n"
-            else:
-                current += f"    {n}: {t} = {json.dumps(default)}\n"
-        if len(schema["fields"]) == 0:
-            current += "    pass\n"
-
-        classes[name] = current
-
-    record_type_to_pydantic(schema)
-
-    file_content = """
-from datetime import date, datetime, time
-from decimal import Decimal
-from enum import Enum
-from typing import List, Optional, Dict, Union
-from uuid import UUID
-
-from pydantic import BaseModel, Field
-
-
-"""
-    file_content += "\n\n".join(classes.values())
-
-    return file_content
-
-
-def convert_file(avsc_path: str, output_path: Optional[str] = None):
-    with open(avsc_path, "r") as fh:
-        avsc_dict = json.load(fh)
-    file_content = avsc_to_pydantic(avsc_dict)
-    if output_path is None:
-        print(file_content)
-    else:
-        with open(output_path, "w") as fh:
-            fh.write(file_content)

pydantic_avro-0.6.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-LICENSE,sha256=gBlYCG1yxb0vGlsmek0lMPVOK5YDxQope4F54jzeqoY,1069
-pydantic_avro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_avro/__main__.py,sha256=O0GAVHLzCYv3rSNpOv6JQ0xXjIe0k_76ZWSw7YpAlvw,685
-pydantic_avro/avro_to_pydantic.py,sha256=6l7XcD0AXfnR_8UqE1RfnLs263n_r9DUmWfIV8F5Osw,5180
-pydantic_avro/base.py,sha256=RNCOXgrFZEeboUjJctRRy6An_V0AIOuFDzbLJmt74xs,8032
-pydantic_avro-0.6.5.dist-info/entry_points.txt,sha256=gwHiQfbGLO8Np2sa1bZ_bpxU7sEufx6IachViBE_Fnw,66
-pydantic_avro-0.6.5.dist-info/LICENSE,sha256=gBlYCG1yxb0vGlsmek0lMPVOK5YDxQope4F54jzeqoY,1069
-pydantic_avro-0.6.5.dist-info/WHEEL,sha256=vxFmldFsRN_Hx10GDvsdv1wroKq8r5Lzvjp6GZ4OO8c,88
-pydantic_avro-0.6.5.dist-info/METADATA,sha256=bpH0VeOOSWZd9kdMkp9cJakD8TC1zM9vbAdlfKPXIXQ,2667
-pydantic_avro-0.6.5.dist-info/RECORD,,