Schemas as instances, not classes

Author: lovelydinosaur

tests/test_forms.py

@@ -14,7 +14,7 @@ class Contact(typesystem.Schema):
 
 
 def test_form_rendering():
-    form = forms.Form(Contact)
+    form = forms.create_form(Contact)
 
     html = str(form)
 
@@ -28,13 +28,14 @@ def test_password_rendering():
     class PasswordForm(typesystem.Schema):
         password = typesystem.String(format="password")
 
-    form = forms.Form(PasswordForm, values={"password": "secret"})
+    form = forms.create_form(PasswordForm)
+    form.validate(data={"password": "secret"})
     html = str(form)
     assert "secret" not in html
 
 
 def test_form_html():
-    form = forms.Form(Contact)
+    form = forms.create_form(Contact)
 
     markup = form.__html__()
 

tests/test_schemas.py

@@ -6,6 +6,54 @@
 
 import typesystem
 import typesystem.formats
+from typesystem import Integer, Scheme
+
+
+def test_scheme():
+    validator = Scheme(fields={})
+    value, error = validator.validate_or_error({})
+    assert value == {}
+
+    validator = Scheme(fields={})
+    value, error = validator.validate_or_error(None)
+    assert dict(error) == {"": "May not be null."}
+
+    validator = Scheme(fields={})
+    value, error = validator.validate_or_error(123)
+    assert dict(error) == {"": "Must be an object."}
+
+    validator = Scheme(fields={})
+    value, error = validator.validate_or_error({1: 123})
+    assert dict(error) == {1: "All object keys must be strings."}
+
+    validator = Scheme(fields={}, allow_null=True)
+    value, error = validator.validate_or_error(None)
+    assert value is None
+    assert error is None
+
+    validator = Scheme(fields={"example": Integer()})
+    value, error = validator.validate_or_error({"example": "123"})
+    assert value == {"example": 123}
+
+    validator = Scheme(fields={"example": Integer()})
+    value, error = validator.validate_or_error({"example": "abc"})
+    assert dict(error) == {"example": "Must be a number."}
+
+    validator = Scheme(fields={"example": Integer(default=0)})
+    value, error = validator.validate_or_error({"example": "123"})
+    assert value == {"example": 123}
+
+    validator = Scheme(fields={"example": Integer(default=0)})
+    value, error = validator.validate_or_error({})
+    assert value == {"example": 0}
+
+    validator = Scheme(fields={"example": Integer()})
+    value, error = validator.validate_or_error({"example": "abc"})
+    assert dict(error) == {"example": "Must be a number."}
+
+    validator = Scheme(fields={"example": Integer(read_only=True)})
+    value, error = validator.validate_or_error({"example": "123"})
+    assert value == {}
 
 
 class Person(typesystem.Schema):

typesystem/__init__.py

@@ -13,6 +13,7 @@
     Number,
     Object,
     String,
+    Scheme,
     Text,
     Time,
     Union,

typesystem/fields.py

@@ -28,6 +28,7 @@ def __init__(
         description: str = "",
         default: typing.Any = NO_DEFAULT,
         allow_null: bool = False,
+        read_only: bool = False
     ):
         assert isinstance(title, str)
         assert isinstance(description, str)
@@ -41,6 +42,7 @@ def __init__(
         self.title = title
         self.description = description
         self.allow_null = allow_null
+        self.read_only = read_only
 
         # We need this global counter to determine what order fields have
         # been declared in when used with `Schema`.
@@ -680,6 +682,85 @@ def serialize(self, obj: typing.Any) -> typing.Any:
         return [self.items.serialize(value) for value in obj]
 
 
+class Scheme(Field):
+    errors = {
+        "type": "Must be an object.",
+        "null": "May not be null.",
+        "invalid_key": "All object keys must be strings.",
+        "required": "This field is required.",
+    }
+
+    def __init__(
+        self,
+        fields: typing.Dict[str, Field],
+        **kwargs: typing.Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.fields = fields
+        self.required = [key for key, field in fields.items() if not (field.read_only or field.has_default())]
+
+    def validate(self, value: typing.Any) -> typing.Any:
+        if value is None and self.allow_null:
+            return None
+        elif value is None:
+            raise self.validation_error("null")
+        elif not isinstance(value, (dict, typing.Mapping)):
+            raise self.validation_error("type")
+
+        validated = {}
+        error_messages = []
+
+        # Ensure all property keys are strings.
+        for key in value.keys():
+            if not isinstance(key, str):
+                text = self.get_error_text("invalid_key")
+                message = Message(text=text, code="invalid_key", index=[key])
+                error_messages.append(message)
+
+        # Required properties
+        for key in self.required:
+            if key not in value:
+                text = self.get_error_text("required")
+                message = Message(text=text, code="required", index=[key])
+                error_messages.append(message)
+
+        # Properties
+        for key, child_schema in self.fields.items():
+            if child_schema.read_only:
+                continue
+
+            if key not in value:
+                if child_schema.has_default():
+                    validated[key] = child_schema.get_default_value()
+                continue
+            item = value[key]
+            child_value, error = child_schema.validate_or_error(item)
+            if not error:
+                validated[key] = child_value
+            else:
+                error_messages += error.messages(add_prefix=key)
+
+        if error_messages:
+            raise ValidationError(messages=error_messages)
+
+        return validated
+
+    def serialize(self, obj: typing.Any) -> typing.Any:
+        if obj is None:
+            return None
+
+        is_mapping = isinstance(obj, dict)
+
+        ret = {}
+        for key, field in self.fields.items():
+            try:
+                value = obj[key] if is_mapping else getattr(obj, key)
+            except (KeyError, AttributeError):
+                continue
+            ret[key] = field.serialize(value)
+        return ret
+
+
 class Text(String):
     def __init__(self, **kwargs: typing.Any) -> None:
         super().__init__(format="text", **kwargs)

typesystem/formats.py

@@ -118,7 +118,7 @@ def validate(self, value: typing.Any) -> datetime.datetime:
             raise self.validation_error("format")
 
         groups = match.groupdict()
-        if groups["microsecond"]:
+        if groups["microsecond"] is not None:
             groups["microsecond"] = groups["microsecond"].ljust(6, "0")
 
         tzinfo_str = groups.pop("tzinfo")

typesystem/forms.py

@@ -35,19 +35,40 @@ def __init__(
         *,
         env: "jinja2.Environment",
         schema: typing.Type[Schema],
-        values: dict = None,
-        errors: ValidationError = None,
+        instance: typing.Any = None
     ) -> None:
         self.env = env
         self.schema = schema
-        self.values = values
-        self.errors = errors
+        self.instance = instance
+        self.values = None if instance is None else self.schema.serialize(instance)
+        self.errors = None
+        self._validate_called = False
+
+    def validate(self, data: dict = None):
+        assert not self._validate_called, 'validate() has already been called.'
+        self.data = data
+        self.values, self.errors = self.schema.validate_or_error(data)
+        self._validate_called = True
+
+    @property
+    def is_valid(self):
+        assert self._validate_called, 'validate() has not been called.'
+        return self.errors is None
+
+    @property
+    def validated_data(self):
+        return self.values
 
     def render_fields(self) -> str:
+        values = self.data if self.errors else self.values
+        errors = self.errors
+
         html = ""
         for field_name, field in self.schema.fields.items():
-            value = None if self.values is None else self.values.get(field_name)
-            error = None if self.errors is None else self.errors.get(field_name)
+            if field.read_only:
+                continue
+            value = None if values is None else values.get(field_name)
+            error = None if errors is None else errors.get(field_name)
             html += self.render_field(
                 field_name=field_name, field=field, value=value, error=error
             )
@@ -61,8 +82,8 @@ def render_field(
         value: typing.Any = None,
         error: str = None,
     ) -> str:
-        field_id_prefix = "form-" + self.schema.__name__.lower() + "-"
-        field_id = field_id_prefix + field_name.replace("_", "-")
+        # field_id_prefix = "form-" + self.schema.__name__.lower() + "-"
+        # field_id = field_id_prefix + field_name.replace("_", "-")
         label = field.title or field_name
         allow_empty = field.allow_null or getattr(field, "allow_blank", False)
         required = not field.has_default() and not allow_empty
@@ -72,7 +93,7 @@ def render_field(
         value = "" if input_type == "password" else value
         return template.render(
             {
-                "field_id": field_id,
+                # "field_id": field_id,
                 "field_name": field_name,
                 "field": field,
                 "label": label,
@@ -135,11 +156,9 @@ def load_template_env(
             )
         return jinja2.Environment(loader=loader, autoescape=True)
 
-    def Form(
+    def create_form(
         self,
         schema: typing.Type[Schema],
-        *,
-        values: dict = None,
-        errors: ValidationError = None,
+        instance: typing.Any = None
     ) -> Form:  # type: ignore
-        return Form(env=self.env, schema=schema, values=values, errors=errors)
+        return Form(env=self.env, schema=schema, instance=instance)