chore: make release-ready for initial distribution (#27)

Author: jsstevenson

.github/workflows/pypi_publish.yaml

@@ -0,0 +1,24 @@
+name: Upload package to PyPI
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+    - name: Install dependencies
+      run: |
+        python3 -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI }}
+      run: |
+        python3 setup.py sdist bdist_wheel
+        twine upload dist/*

.pre-commit-config.yaml

@@ -1,5 +1,3 @@
-# See https://pre-commit.com for more information
-# See https://pre-commit.com/hooks.html for more hooks
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v1.4.0
@@ -9,8 +7,10 @@ repos:
   rev: 22.3.0
   hooks:
     - id: black
-      # It is recommended to specify the latest version of Python
-      # supported by your project here, or alternatively use
-      # pre-commit's default_language_version, see
-      # https://pre-commit.com/#top_level-default_language_version
+      args: ["--check"]
       language_version: python3.10
+- repo: https://github.com/pycqa/isort
+  rev: 5.6.4
+  hooks:
+    - id: isort
+      args: ["--profile", "black", "--check"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 James Stevenson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,82 @@
+<h1 align="center">
+    Oxley: Pydantic classes from JSON schema
+</h1>
+
+**Oxley** generates [Pydantic](https://github.com/samuelcolvin/pydantic) classes at runtime from user-provided JSON schema documents. Heavily indebted to packages like [Python-JSONschema-Objects](https://github.com/cwacek/python-jsonschema-objects), Oxley enables data validation pipelines to function dynamically, and with the help of Pydantic, interface directly with popular web frameworks such as [FastAPI](https://github.com/tiangolo/fastapi) and [Starlite](https://github.com/starlite-api/starlite).
+
+## Quick start
+
+Install from PIP:
+
+```shell
+python3 -m pip install oxley
+```
+
+Given a simple JSONschema document:
+
+```json
+{
+  "$id": "https://github.com/jsstevenson/oxley",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$defs": {
+    "User": {
+      "type": "object",
+      "properties": {
+        "username": {"type": "string"},
+        "user_id": {"type": "number"}
+      },
+      "required": ["username", "user_id"]
+    },
+    "Post": {
+      "type": "object",
+      "properties": {
+        "author": {"$ref": "#/$defs/User"},
+        "content": {"type": "string"},
+        "allow_responses": {"type": "boolean"}
+      },
+      "required": ["author", "content"]
+    }
+  }
+}
+```
+
+Provide a schema and construct classes:
+
+``` python
+from oxley import ClassBuilder
+schema_path = "path/to/my_jsonschema_document.json"
+cb = ClassBuilder(schema_path)
+User, Post = cb.build_classes()
+```
+
+The resulting objects are functioning Pydantic classes, providing features like runtime data validation and matching schema output.
+
+``` python
+dril = User(username="dril", user_id=99)
+post = Post(author=dril, content="should i learn Letters first?  or choose the path of Numbers? a queston every baby must ask it self")
+another_post = Post(author=dril)  # raises pydantic.ValidationError
+```
+
+## Development
+
+Clone and install dev and test dependencies:
+
+``` shell
+git clone https://github.com/jsstevenson/oxley
+cd oxley
+# make virtual environment of your choosing
+python3 -m pip install ".[dev,test]"
+```
+
+Install pre-commit hooks:
+
+``` shell
+pre-commit install
+```
+
+Run tests with tox:
+
+```
+tox
+```

oxley/__init__.py

@@ -0,0 +1,12 @@
+"""Initialize module."""
+import logging
+import sys
+
+from .class_builder import ClassBuilder
+from .version import __version__
+
+__all__ = ["ClassBuilder"]
+
+logging.basicConfig(
+    handlers=[logging.FileHandler("oxley.log"), logging.StreamHandler()]
+)

respected_wizard/class_builder.py oxley/class_builder.pyrespected_wizard/class_builder.py renamed to oxley/class_builder.py

@@ -1,39 +1,43 @@
 """Provide class construction tools."""
+import json
+import logging
+import re
+from enum import Enum
+from pathlib import Path
 from typing import (
     Any,
     Callable,
-    Literal,
-    Optional,
     Dict,
     ForwardRef,
     List,
+    Literal,
+    Optional,
     Set,
     Tuple,
     Union,
 )
-from enum import Enum
-from pathlib import Path
-import json
-import logging
-import re
 
-from pydantic import create_model
+import requests
+from pydantic import create_model, validator
+from pydantic.class_validators import root_validator
 from pydantic.fields import Field, Undefined
 from pydantic.main import BaseModel
-import requests
-from respected_wizard.pydantic_utils import get_configs
 
-from respected_wizard.schema_versions import SchemaVersion, resolve_schema_version
-from respected_wizard.typing import resolve_type
-from respected_wizard.exceptions import (
+from .exceptions import (
     InvalidReferenceException,
     SchemaConversionException,
     UnsupportedSchemaException,
 )
+from .pydantic_utils import get_configs
+from .schema_versions import SchemaVersion, resolve_schema_version
+from .types import resolve_type
 
 logging.basicConfig(
     level=logging.INFO,
-    handlers=[logging.FileHandler("respected_wizard.log"), logging.StreamHandler()],
+    handlers=[
+        logging.FileHandler("pydantic_jsonschema_objects.log"),
+        logging.StreamHandler(),
+    ],
 )
 
 logger = logging.getLogger(__name__)
@@ -65,8 +69,7 @@ def build_classes(self) -> List:
         for name, definition in self.schema[self.def_keyword].items():
             self._build_class(name, definition)
         while len(self.external_schemas) > 0:
-            external_name: str = self.external_schemas[0][0]
-            external_definition: Dict = self.external_schemas[0][1]
+            external_name, external_definition = self.external_schemas[0]
             self._build_class(external_name, external_definition)
             self.external_schemas = self.external_schemas[1:]
 
@@ -83,8 +86,17 @@ def _build_class(self, name: str, definition: Dict) -> None:
 
     def _build_primitive_class(self, name: str, definition: Dict):
         """
-        Construct classes derived from basic primitives (eg strings).
+        Construct classes derived from basic primitives (eg strings). Bare strings and
+        numbers don't need to come through here, but any class that bounds their
+        possible values will. Updates `self.local_ns` with completed class definition.
         Currently only supports strings.
+
+        Args:
+            name: class name
+            definition: class properties from schema
+
+        Raises:
+            UnsupportedSchemaException: if non-string classes are provided.
         """
         attributes = {}
         type_tuple: Tuple = ()
@@ -126,10 +138,6 @@ def validate(cls, v):
         model = type(name, type_tuple, attributes)
         self.local_ns[name] = model
 
-    def _handle_class_deprecation(self, name: str, definition: Dict):
-        if definition.get("deprecated"):
-            logger.warning(f"Class {name} is deprecated.")
-
     def _build_object_class(self, name: str, definition: Dict):
         """
         Construct object-based class.
@@ -141,13 +149,26 @@ def _build_object_class(self, name: str, definition: Dict):
         Args:
             name: name of the object class
             definition: dictionary containing class properties
+
+        Raise:
+            SchemaConversionException:
+             * if unsupported types are provided as consts
         """
         fields: Dict[str, Union[Tuple[Any, Any], Callable]] = {}
         has_forward_ref = False
         required_fields = definition.get("required", set())
         allow_population_by_field_name = False
+        validators: Dict = {}
+
+        if definition.get("deprecated") is True:
 
-        self._handle_class_deprecation(name, definition)
+            def class_deprecation_warning(cls, values):
+                logger.warning(f"Class {name} is deprecated.")
+                return values
+
+            validators["class_deprecated"] = root_validator(pre=True, allow_reuse=True)(
+                class_deprecation_warning
+            )
 
         for prop_name, prop_attrs in definition["properties"].items():
             if "$ref" in prop_attrs:
@@ -180,11 +201,22 @@ def dict(self):
 
                 fields["dict"] = dict
 
+            if prop_attrs.get("deprecated") is True:
+
+                def property_deprecated_warning(cls, v):
+                    logger.warning(f"Property {name}.{prop_name} is deprecated")
+                    return v
+
+                validators[f"{prop_name}_deprecated"] = validator(
+                    prop_name, allow_reuse=True
+                )(property_deprecated_warning)
+
             if "const" in prop_attrs:
                 const_value = prop_attrs["const"]
                 if not any(
                     [isinstance(const_value, t) for t in (str, int, float, bool)]
                 ):
+                    # TODO -- construct complex object consts
                     raise SchemaConversionException
                 else:
                     const_type = Literal[const_value]  # type: ignore
@@ -195,14 +227,16 @@ def dict(self):
             elif "enum" in prop_attrs:
                 vals = {str(p).upper(): p for p in prop_attrs["enum"]}
                 enum_type = Enum(prop_name, vals, type=str)  # type: ignore
+                if prop_name not in required_fields:
+                    enum_type = Optional[enum_type]  # type: ignore
                 fields[prop_name] = (enum_type, Field(**field_args))
             else:
                 if prop_name not in required_fields:
                     field_type = Optional[field_type]
                 fields[prop_name] = (field_type, Field(**field_args))
 
         config = get_configs(name, definition, allow_population_by_field_name)
-        model = create_model(__model_name=name, __config__=config, **fields)  # type: ignore
+        model = create_model(__model_name=name, __config__=config, __validators__=validators, **fields)  # type: ignore
         if "description" in definition:
             model.__doc__ = definition["description"]
 

respected_wizard/exceptions.py oxley/exceptions.pyrespected_wizard/exceptions.py renamed to oxley/exceptions.py

@@ -1,11 +1,10 @@
 """Define miscellaneous utilities for working with Pydantic classes."""
 import logging
-from typing import Type, Dict, Any
+from typing import Any, Dict, Type
 
 from pydantic import BaseConfig
 from pydantic.config import Extra
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -15,7 +14,7 @@ def get_configs(
     """
     Set model configs from definition attributes. This part of Pydantic gets a little
     hairy, so lots of type check suppression is needed to ensure successful
-    conformity to the necessary arg forms.
+    conformity to the necessary arg structure.
 
     Args:
         name: class name
@@ -49,9 +48,14 @@ def schema_extra_function(schema: Dict[str, Any], model: Type[name]) -> None:  #
 
         schema_extra_value = schema_extra_function  # type: ignore
 
-    class ModifiedConfig(BaseConfig):
-        extra: Extra = extra_value
-        allow_population_by_field_name = allow_population_by_field_name_setting
-        schema_extra = schema_extra_value  # type: ignore
+    ModifiedConfig = type(
+        f"{name}Config",
+        (BaseConfig,),
+        {
+            "extra": extra_value,
+            "allow_population_by_field_name": allow_population_by_field_name_setting,
+            "schema_extra": schema_extra_value,
+        },
+    )
 
     return ModifiedConfig

respected_wizard/pydantic_utils.py oxley/pydantic_utils.pyrespected_wizard/pydantic_utils.py renamed to oxley/pydantic_utils.py

@@ -2,7 +2,7 @@
 import re
 from enum import Enum
 
-from respected_wizard.exceptions import UnsupportedSchemaException
+from .exceptions import UnsupportedSchemaException
 
 
 class SchemaVersion(str, Enum):
@@ -14,7 +14,7 @@ class SchemaVersion(str, Enum):
 
 SCHEMA_MATCH_PATTERNS = {
     re.compile(
-        r"^http(s)?://(www\.)?json-schema.org/draft/2020-12/schema$"
+        r"^https://(www\.)?json-schema.org/draft/2020-12/schema$"
     ): SchemaVersion.DRAFT_2020_12,
     re.compile(
         r"^http(s)?://(www\.)?json-schema.org/draft-07/schema$"