Using Injecty instead of native DI

Author: Tim O'Farrell

injecty_config_schemey/__init__.py

@@ -0,0 +1,50 @@
+from injecty import InjectyContext
+from marshy.marshaller.marshaller_abc import MarshallerABC
+
+from schemey.factory.any_of_schema_factory import AnyOfSchemaFactory
+from schemey.factory.array_schema_factory import ArraySchemaFactory
+from schemey.factory.dataclass_schema_factory import DataclassSchemaFactory
+from schemey.factory.datetime_factory import DatetimeFactory
+from schemey.factory.enum_schema_factory import EnumSchemaFactory
+from schemey.factory.external_type_factory import ExternalTypeFactory
+from schemey.factory.factory_schema_factory import FactorySchemaFactory
+from schemey.factory.impl_schema_factory import ImplSchemaFactory
+from schemey.factory.ref_schema_factory import RefSchemaFactory
+from schemey.factory.schema_factory_abc import SchemaFactoryABC
+from schemey.factory.simple_type_factory import BoolTypeFactory, IntTypeFactory, NoneTypeFactory, FloatFactory, \
+    StrFactory
+from schemey.factory.tuple_schema_factory import TupleSchemaFactory
+from schemey.factory.uuid_factory import UuidFactory
+from schemey.json_schema.ranges_validator import RangesValidator
+from schemey.json_schema.schema_validator_abc import SchemaValidatorABC
+from schemey.json_schema.timestamp_validator import TimestampValidator
+from schemey.schema_marshaller import SchemaMarshaller
+
+priority = 100
+
+
+def configure(context: InjectyContext):
+    context.register_impl(MarshallerABC, SchemaMarshaller)
+    context.register_impls(SchemaFactoryABC, [
+        RefSchemaFactory,
+        BoolTypeFactory,
+        IntTypeFactory,
+        NoneTypeFactory,
+        FloatFactory,
+        StrFactory,
+        DatetimeFactory,
+        UuidFactory,
+        ArraySchemaFactory,
+        TupleSchemaFactory,
+        ExternalTypeFactory,
+        DataclassSchemaFactory,
+        EnumSchemaFactory,
+        FactorySchemaFactory,
+        ImplSchemaFactory,
+        AnyOfSchemaFactory,
+    ])
+
+    context.register_impls(SchemaValidatorABC, [
+        RangesValidator,
+        TimestampValidator,
+    ])

marshy_config_schemey/__init__.py

@@ -1,13 +1,9 @@
-import importlib
-import pkgutil
-from typing import Optional, Type
+from typing import Type
 
-from marshy import get_default_context
-from marshy.marshaller_context import MarshallerContext
 from marshy.types import ExternalItemType
 
 from schemey.schema import Schema
-from schemey.schema_context import SchemaContext
+from schemey.schema_context import SchemaContext, create_schema_context
 
 _default_context = None
 CONFIG_MODULE_PREFIX = "schemey_config_"
@@ -17,27 +13,10 @@
 def get_default_schema_context() -> SchemaContext:
     global _default_context
     if not _default_context:
-        _default_context = new_default_schema_context()
+        _default_context = create_schema_context()
     return _default_context
 
 
-def new_default_schema_context(
-    marshaller_context: Optional[MarshallerContext] = None,
-) -> SchemaContext:
-    if marshaller_context is None:
-        marshaller_context = get_default_context()
-    context = SchemaContext(marshaller_context=marshaller_context)
-    # Set up context based on naming convention
-    module_info = (
-        m for m in pkgutil.iter_modules() if m.name.startswith(CONFIG_MODULE_PREFIX)
-    )
-    modules = [importlib.import_module(m.name) for m in module_info]
-    modules.sort(key=lambda m: m.priority, reverse=True)
-    for m in modules:
-        getattr(m, "configure")(context)
-    return context
-
-
 def schema_from_type(type_: Type) -> Schema:
     return get_default_schema_context().schema_from_type(type_)
 

schemey/__init__.py

@@ -44,7 +44,7 @@ def from_type(
                 required.append(field.name)
             if field.default is not dataclasses.MISSING:
                 field_schema = Schema({**field_schema.schema}, field_schema.python_type)
-                field_schema.schema["default"] = context.marshaller_context.dump(
+                field_schema.schema["default"] = context.marshy_context.dump(
                     field.default, types[field.name]
                 )
             properties[field.name] = field_schema.schema
@@ -95,7 +95,7 @@ def from_json(
             )
             default = field_item.get("default", dataclasses.MISSING)
             if default is not dataclasses.MISSING:
-                default = context.marshaller_context.load(
+                default = context.marshy_context.load(
                     field_schema.python_type, default
                 )
                 p = params_with_default

schemey/factory/dataclass_schema_factory.py

@@ -1,7 +1,6 @@
 from dataclasses import dataclass
-from typing import Type, Optional, Set, Dict
+from typing import Type, Optional, Dict
 
-from marshy.factory.impl_marshaller_factory import ImplMarshallerFactory
 from marshy.types import ExternalItemType
 
 from schemey.factory.schema_factory_abc import SchemaFactoryABC
@@ -17,7 +16,6 @@ class ImplSchemaFactory(SchemaFactoryABC):
     structure - though the UnionFactory will make a reasonably standardized class
     structure from the result.
     """
-
     priority: int = 150
 
     def from_type(
@@ -27,7 +25,8 @@ def from_type(
         path: str,
         ref_schemas: Dict[Type, Schema],
     ) -> Optional[Schema]:
-        impls = self.get_impls(type_, context)
+        # noinspection PyTypeChecker
+        impls = context.marshy_context.injecty_context.get_impls(type_, permit_no_impl=True)
         if impls:
             impls = sorted(list(impls), key=lambda i: i.__name__)
             any_of = []
@@ -55,17 +54,7 @@ def from_json(
         name = item.get("name")
         if not name or not item.get("anyOf"):
             return
-        factories = context.marshaller_context.get_factories()
-        for factory in factories:
-            if isinstance(factory, ImplMarshallerFactory):
-                if factory.base.__name__ == name:
-                    schema = self.from_type(factory.base, context, path, ref_schemas)
-                    return schema
-
-    @staticmethod
-    def get_impls(type_: Type, context: SchemaContext) -> Optional[Set[Type]]:
-        factories = context.marshaller_context.get_factories()
-        for factory in factories:
-            if isinstance(factory, ImplMarshallerFactory):
-                if factory.base == type_:
-                    return factory.impls
+        for base, impls in context.marshy_context.injecty_context.impls.items():
+            if base.__name__ == name:
+                schema = self.from_type(base, context, path, ref_schemas)
+                return schema

schemey/factory/impl_schema_factory.py

@@ -5,20 +5,18 @@
 from marshy.types import ExternalItemType
 
 from schemey.schema import Schema
-from schemey.schema_context import SchemaContext
+
+_SchemaContext = "schemey.schema_context.SchemaContext"
 
 
-@total_ordering
 class SchemaFactoryABC(ABC):
-    @property
-    def priority(self):
-        return 100
+    priority: int = 100
 
     @abstractmethod
     def from_type(
         self,
         type_: Type,
-        context: SchemaContext,
+        context: _SchemaContext,
         path: str,
         ref_schemas: Dict[Type, Schema],
     ) -> Optional[Schema]:
@@ -30,13 +28,10 @@ def from_type(
     def from_json(
         self,
         item: ExternalItemType,
-        context: SchemaContext,
+        context: _SchemaContext,
         path: str,
         ref_schemas: Dict[str, Schema],
     ) -> Optional[Schema]:
         """
         Create a schema for the type given, or return None if that was not possible
         """
-
-    def __lt__(self, other):
-        return self.priority < getattr(other, "priority", None)

schemey/factory/schema_factory_abc.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from types import NoneType
 from typing import Optional, Type, Dict
 
 from marshy.types import ExternalItemType
@@ -34,3 +35,33 @@ def from_json(
         type_ = item.get("type")
         if type_ == self.json_type:
             return Schema(item, self.python_type)
+
+
+@dataclass
+class BoolTypeFactory(SimpleTypeFactory):
+    python_type: Type = bool
+    json_type: str = "boolean"
+
+
+@dataclass
+class IntTypeFactory(SimpleTypeFactory):
+    python_type: Type = int
+    json_type: str = "integer"
+
+
+@dataclass
+class NoneTypeFactory(SimpleTypeFactory):
+    python_type: Type = NoneType
+    json_type: str = "null"
+
+
+@dataclass
+class FloatFactory(SimpleTypeFactory):
+    python_type: Type = float
+    json_type: str = "number"
+
+
+@dataclass
+class StrFactory(SimpleTypeFactory):
+    python_type: Type = str
+    json_type: str = "string"

schemey/factory/simple_type_factory.py

@@ -1,11 +0,0 @@
-from typing import Callable, Dict
-
-_custom_validators = {}
-
-
-def register_custom_json_schema_validator(property_name: str, validator: Callable):
-    _custom_validators[property_name] = validator
-
-
-def get_custom_json_schema_validators() -> Dict[str, Callable]:
-    return _custom_validators

schemey/json_schema/__init__.py

@@ -0,0 +1,48 @@
+from jsonschema.exceptions import ValidationError
+
+from schemey.json_schema.schema_validator_abc import SchemaValidatorABC
+
+
+class RangesValidator(SchemaValidatorABC):
+    """
+    Add a custom validation rule for ranges to json object schema.
+    e.g.:
+
+    {
+        "type": "object",
+        "properties": {
+            "min_value": {"type": "integer", "minimum": 5},
+            "max_value": {"type": "integer"}
+        },
+        "required": ["min_value", "max_value"],
+        "ranges": [{
+            "minProperty": "min_value",
+            "maxProperty": "max_value",
+            "allowEqual": false
+        }]
+    }
+    """
+    property_name: str = "ranges"
+
+    def validate(self, validator, aP, instance, schema):
+        if not validator.is_type(instance, "object"):
+            return
+        ranges_ = schema.get("ranges") or []
+        for range_ in ranges_:
+            min_property = range_["minProperty"]
+            max_property = range_["maxProperty"]
+            allow_equal = range_.get("allowEqual")
+            min_value = instance.get(min_property)
+            max_value = instance.get(max_property)
+            if min_value < max_value:
+                continue
+            if allow_equal and min_value == max_value:
+                continue
+            # pylint: disable=R0801
+            yield ValidationError(
+                f"Value not in future: {instance}",
+                validator=validator,
+                validator_value=aP,
+                instance=instance,
+                schema=schema,
+            )

schemey/json_schema/ranges.py

@@ -0,0 +1,8 @@
+from abc import ABC
+
+
+class SchemaValidatorABC(ABC):
+    property_name: str
+
+    def validate(self, validator, aP, instance, schema):
+        """ Validate this property """