localstack-py-avro-schema 3.9.2__py3-none-any.whl → 3.9.4__py3-none-any.whl

{localstack_py_avro_schema-3.9.2.dist-info → localstack_py_avro_schema-3.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-py-avro-schema
-Version: 3.9.2
+Version: 3.9.4
 Summary: Generate Apache Avro schemas for Python types including standard library data-classes and Pydantic data models.
 Author-email: LocalStack Contributors <info@localstack.cloud>, "J.P. Morgan Chase & Co." <open_source@jpmorgan.com>
 License:                                  Apache License

{localstack_py_avro_schema-3.9.2.dist-info → localstack_py_avro_schema-3.9.4.dist-info}/RECORD

@@ -1,12 +1,12 @@
-localstack_py_avro_schema-3.9.2.dist-info/licenses/LICENSE,sha256=zE1N4JILDTkSIDtdmqdnKKxKEQh_VdqeoAV2230eNOI,10141
-localstack_py_avro_schema-3.9.2.dist-info/licenses/LICENSE_HEADER.txt,sha256=Nx3RGmYbJKjIKM8Y2yMrCPJgCw4oBt_H62PxDKlAsto,564
+localstack_py_avro_schema-3.9.4.dist-info/licenses/LICENSE,sha256=zE1N4JILDTkSIDtdmqdnKKxKEQh_VdqeoAV2230eNOI,10141
+localstack_py_avro_schema-3.9.4.dist-info/licenses/LICENSE_HEADER.txt,sha256=Nx3RGmYbJKjIKM8Y2yMrCPJgCw4oBt_H62PxDKlAsto,564
 py_avro_schema/__init__.py,sha256=bK6hTw4XJy5bAP4lgIvJR5LHtEiyUWq4GNJ5w-uSEpc,2414
 py_avro_schema/_alias.py,sha256=nCQqtn7IbpjV0ibpJf9aMX9FvwVx2EDC1iKzwjQ7CqI,3412
-py_avro_schema/_schemas.py,sha256=I5otHWPh8tcws3ey4iwsx7c0Zz1VNLmMTabTh43E-7s,46993
+py_avro_schema/_schemas.py,sha256=L9_c-I1ihS9BJpXe1-foDMUppxY7PyTT544hMbrS1TM,48589
 py_avro_schema/_testing.py,sha256=3aSfMbNDDeatl3H7GEUcynxK81HFiF-WCLOZ3FCCLiw,2261
 py_avro_schema/_typing.py,sha256=9kBlPA7C33zZP3nRhCvSJA_0m54uvUo0AQ4wJJmSxMk,3291
 py_avro_schema/py.typed,sha256=HnEDkaznpgfRW07Qfogy4tFLu_4dcQ5YcOsI7pmU5rQ,52
-localstack_py_avro_schema-3.9.2.dist-info/METADATA,sha256=6K-dy4M5Pj2-uoHcRF15vZVRz7pfiibgQcAnysW4YKY,15164
-localstack_py_avro_schema-3.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-localstack_py_avro_schema-3.9.2.dist-info/top_level.txt,sha256=0t4oO_5rsdfZGSk8iSzK4TjdyfVz-RE1IZ2TIz6YvI0,15
-localstack_py_avro_schema-3.9.2.dist-info/RECORD,,
+localstack_py_avro_schema-3.9.4.dist-info/METADATA,sha256=2VBFpx5j-KsRbwOmtIICNMNLSgB34kwkCra0Jh_WO5U,15164
+localstack_py_avro_schema-3.9.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+localstack_py_avro_schema-3.9.4.dist-info/top_level.txt,sha256=0t4oO_5rsdfZGSk8iSzK4TjdyfVz-RE1IZ2TIz6YvI0,15
+localstack_py_avro_schema-3.9.4.dist-info/RECORD,,

py_avro_schema/_schemas.py

@@ -45,9 +45,11 @@ from typing import (
     get_type_hints,
 )
 
+import avro.name
 import more_itertools
 import orjson
 import typeguard
+from avro.errors import InvalidName
 
 import py_avro_schema._typing
 from py_avro_schema._alias import get_aliases, get_field_aliases_and_actual_type
@@ -135,9 +137,10 @@ JSON_OPTIONS = [opt for opt in Option if opt.name and opt.name.startswith("JSON_
 _SCHEMA_CLASSES = []
 
 
-def register_schema(cls):
+def register_schema(cls: type | None = None, *, priority: int = 0):
     """
     Decorator to register a class as a known ``Schema``
+    It also accept a priority value to sort the list of schemas. Default schemas have priority 0.
 
     Schema classes are instantiated when calling ``schema``. Example use::
 
@@ -147,10 +150,15 @@ def register_schema(cls):
           def handles_type(cls, py_type: Type) -> bool:
               ...
           ...
-
     """
-    _SCHEMA_CLASSES.append(cls)
-    return cls
+
+    def _wrapper(_cls):
+        """Wrapper function to attach priority and sort the list of schemas."""
+        _cls.__py_avro_priority = priority
+        _SCHEMA_CLASSES.append(_cls)
+        return _cls
+
+    return _wrapper if not cls else _wrapper(cls)
 
 
 def schema(
@@ -186,7 +194,7 @@ def _schema_obj(py_type: Type, namespace: Optional[str] = None, options: Option
     :param options:   Schema generation options.
     """
     # Find concrete Schema subclasses defined in the current module
-    for schema_class in _SCHEMA_CLASSES:
+    for schema_class in sorted(_SCHEMA_CLASSES, key=lambda c: getattr(c, "__py_avro_priority", 0)):
         # Find the first schema class that handles py_type
         schema_obj = schema_class(py_type, namespace=namespace, options=options)  # type: ignore
         if schema_obj:
@@ -843,19 +851,33 @@ class EnumSchema(NamedSchema):
         if symbol_types != {str}:
             raise TypeError(f"Avro enum schema members must be strings. {py_type} uses {symbol_types} values.")
 
+    def _is_valid_enum(self) -> bool:
+        """Checks if all the symbols of the enum are valid Avro names."""
+        try:
+            for _symbol in self.symbols:
+                avro.name.validate_basename(_symbol)
+        except InvalidName:
+            return False
+        return True
+
     def data_before_deduplication(self, names: NamesType) -> JSONObj:
         """Return the schema data"""
-        enum_schema = {
-            "type": "enum",
-            "name": self.name,
-            "symbols": self.symbols,
-            # This is the default for the enum, not the default value for a record field using the enum type! See Avro
-            # schema specification for use. For now, we force the default value to be the first symbol. This means that
-            # if the writer schema has an additional member that the reader schema does NOT have, the reader will simply
-            # and silently assume the default specified here. Now that may not always be what we want, but standard lib
-            # Python enums don't really have a way to specify this.
-            "default": self.symbols[0],
-        }
+        if not self._is_valid_enum():
+            # Special case for StrEnum might contain invalid avro names. We just use a StrSubclassSchema schema instead.
+            enum_schema = {"type": "string", "namedString": self.name}
+        else:
+            enum_schema = {
+                "type": "enum",
+                "name": self.name,
+                "symbols": self.symbols,
+                # This is the default for the enum, not the default value for a record field using the enum type!
+                # See Avro schema specification for use. For now, we force the default value to be the first symbol.
+                # This means that if the writer schema has an additional member that the reader schema does NOT have,
+                # the reader will simply and silently assume the default specified here.
+                # Now that may not always be what we want, but standard lib Python enums don't really have a way
+                # to specify this.
+                "default": self.symbols[0],
+            }
         if self.namespace is not None:
             enum_schema["namespace"] = self.namespace
             fqn = f"{self.namespace}.{self.name}"
@@ -1064,7 +1086,15 @@ class PydanticSchema(RecordSchema):
 
 @register_schema
 class PlainClassSchema(RecordSchema):
-    """An Avro record schema for a plain Python class with typed constructor method arguments"""
+    """
+    An Avro record schema for a plain Python class with type annotations, e.g.,
+    ::
+        class MyClass:
+            var: str
+
+            def __init__(self, var: str = "foo"):
+                self.var = var
+    """
 
     @classmethod
     def handles_type(cls, py_type: Type) -> bool:
@@ -1077,13 +1107,13 @@ class PlainClassSchema(RecordSchema):
             and not hasattr(py_type, "__pydantic_private__")
             # If we are subclassing a string, used the "named string" approach
             and (inspect.isclass(py_type) and not issubclass(py_type, str))
-            # Any other class with __init__ with typed args
-            and bool(get_type_hints(py_type.__init__))
+            # and any other class with typed annotations
+            and bool(get_type_hints(py_type))
         )
 
     def __init__(self, py_type: Type, namespace: Optional[str] = None, options: Option = Option(0)):
         """
-        An Avro record schema for a plain Python class with typed constructor method arguments
+        An Avro record schema for a plain Python class with type hints
 
         :param py_type:   The Python class to generate a schema for.
         :param namespace: The Avro namespace to add to schemas.
@@ -1091,17 +1121,30 @@ class PlainClassSchema(RecordSchema):
         """
         super().__init__(py_type, namespace=namespace, options=options)
         py_type = _type_from_annotated(py_type)
-        # Extracting arguments from __init__, dropping first argument `self`.
-        self.py_fields = list(inspect.signature(py_type.__init__).parameters.values())[1:]
+
+        self.py_fields: list[tuple[str, type]] = []
+        for k, v in py_type.__annotations__.items():
+            self.py_fields.append((k, v))
+        # We store __init__ parameters with default values. They can be used as defaults for the record.
+        self.signature_fields = {
+            param.name: (param.annotation, param.default)
+            for param in list(inspect.signature(py_type.__init__).parameters.values())[1:]
+            if param.default is not inspect._empty
+        }
         self.record_fields = [self._record_field(field) for field in self.py_fields]
 
-    def _record_field(self, py_field: inspect.Parameter) -> RecordField:
+    def _record_field(self, py_field: tuple[str, Type]) -> RecordField:
         """Return an Avro record field object for a given Python instance attribute"""
-        default = py_field.default if py_field.default != inspect.Parameter.empty else dataclasses.MISSING
-        aliases, actual_type = get_field_aliases_and_actual_type(py_field.annotation)
+        aliases, actual_type = get_field_aliases_and_actual_type(py_field[1])
+        name = py_field[0]
+        default = dataclasses.MISSING
+        if field := self.signature_fields.get(name):
+            _annotation, _default = field
+            if actual_type is _annotation:
+                default = _default
         field_obj = RecordField(
             py_type=actual_type,
-            name=py_field.name,
+            name=name,
             namespace=self.namespace_override,
             default=default,
             aliases=aliases,