localstack-py-avro-schema 3.9.2__tar.gz → 3.9.4__tar.gz

{localstack_py_avro_schema-3.9.2 → localstack_py_avro_schema-3.9.4}/PKG-INFO

@@ -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 → localstack_py_avro_schema-3.9.4}/src/localstack_py_avro_schema.egg-info/PKG-INFO

@@ -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 → localstack_py_avro_schema-3.9.4}/src/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,

{localstack_py_avro_schema-3.9.2 → localstack_py_avro_schema-3.9.4}/tests/test_plain_class.py

@@ -24,6 +24,11 @@ def test_plain_class_with_type_hints():
     class PyType:
         """A port, not using dataclass"""
 
+        name: str
+        country: str
+        latitude: float
+        longitude: float
+
         def __init__(
             self, name: str, *, country: str = "NLD", latitude: float, longitude: float
         ):  # note the non-default kwargs near the end!
@@ -65,6 +70,8 @@ def test_plain_class_annotated():
     class PyType:
         """A port, not using dataclass"""
 
+        name: str
+
         def __init__(self, name: str):
             self.name = name
 
@@ -84,7 +91,9 @@ def test_plain_class_annotated():
 
 def test_field_alias():
     class PyType:
-        def __init__(self, name: Annotated[str, Alias("old_name")]):
+        name: Annotated[str, Alias("old_name")]
+
+        def __init__(self, name):
             self.name = name
 
     expected = {
@@ -105,7 +114,9 @@ def test_plain_class_no_type_hints():
     class PyType:
         """A port, not using dataclass"""
 
-        def __init__(self, name, *, country="NLD", latitude, longitude):  # note the non-default kwargs near the end!
+        def __init__(
+            self, name: str, *, country: str = "NLD", latitude: float, longitude: float
+        ):  # note the non-default kwargs near the end!
             self.name = name
             self.country = country.upper()
             self.latitude = latitude

{localstack_py_avro_schema-3.9.2 → localstack_py_avro_schema-3.9.4}/tests/test_primitives.py

@@ -508,3 +508,14 @@ def test_enum_docs():
         "default": "RED",
     }
     assert_schema(PyType, expected, do_doc=True)
+
+
+def test_str_enum_invalid_name():
+    class OriginProtocolPolicy(str, enum.Enum):
+        http_only = "http-only"
+        match_viewer = "match-viewer"
+        https_only = "https-only"
+
+    expected = {"namedString": "OriginProtocolPolicy", "type": "string"}
+
+    assert_schema(OriginProtocolPolicy, expected)