Update rest of the docs and fix mypy

Author: aminalaee

docs/fields.md

@@ -214,3 +214,4 @@ owner = typesystem.Reference(to="User", allow_null=True, definitions=definitions
 **Arguments**:
 
 * `to` - Name of schema defined in definitions. **Required**
+* `definitions` - `Definitions` instance. **Required**

docs/forms.md

@@ -8,17 +8,21 @@ import typesystem
 
 forms = typesystem.Jinja2Forms(package="typesystem")  # Use the default templates.
 
-class BookingSchema(typesystem.Schema):
-    start_date = typesystem.Date(title="Start date")
-    end_date = typesystem.Date(title="End date")
-    room = typesystem.Choice(title="Room type", choices=[
-        ('double', 'Double room'),
-        ('twin', 'Twin room'),
-        ('single', 'Single room')
-    ])
-    include_breakfast = typesystem.Boolean(title="Include breakfast", default=False)
-
-form = forms.Form(BookingSchema)
+booking_schema = typesystem.Schema(
+    fields={
+        "start_date": typesystem.Date(title="Start date"),
+        "end_date": typesystem.Date(title="End date"),
+        "room": typesystem.Choice(title="Room type", choices=[
+            ('double', 'Double room'),
+            ('twin', 'Twin room'),
+            ('single', 'Single room')
+        ]),
+        "include_breakfast": typesystem.Boolean(title="Include breakfast", default=False),
+
+    }
+)
+
+form = forms.create_form(booking_schema)
 print(form)
 ```
 
@@ -34,39 +38,39 @@ Notice that only the fields in the form are rendered. The surrounding `<form>`,
 ```html
 <tr>
     <td>
-        <label for="form-bookingschema-start-date">Start date</label>
+        <label for="">Start date</label>
     </td>
     <td>
-        <input type="date" id="form-bookingschema-start-date" name="start_date" required>
+        <input type="date" id="" name="start_date" required >
     </td>
 </tr>
 <tr>
     <td>
-        <label for="form-bookingschema-end-date">End date</label>
+        <label for="">End date</label>
     </td>
     <td>
-        <input type="date" id="form-bookingschema-end-date" name="end_date" required>
+        <input type="date" id="" name="end_date" required >
     </td>
 </tr>
 <tr>
     <td>
-        <label for="form-bookingschema-room">Room type</label>
+        <label for="">Room type</label>
     </td>
     <td>
-        <select id="form-bookingschema-room" name="room">
+        <select id="" name="room">
             <option></option>
-            <option value="double">Double room</option>
-            <option value="twin">Twin room</option>
-            <option value="single">Single room</option>
+                <option value="double" >Double room</option>
+                <option value="twin" >Twin room</option>
+                <option value="single" >Single room</option>
         </select>
     </td>
 </tr>
 <tr>
     <td>
-        <label for="form-bookingschema-include-breakfast">Include breakfast</label>
+        <label for="">Include breakfast</label>
     </td>
     <td>
-        <input type="checkbox" id="form-bookingschema-include-breakfast" name="include_breakfast" value="true">
+        <input type="checkbox" id="" name="include_breakfast" value="true" >
     </td>
 </tr>
 ```
@@ -92,15 +96,7 @@ We can include values in a form like so:
 
 ```python
 initial_values = {'room': 'double', 'include_breakfast': True}
-form = forms.Form(BookingSchema, values=initial_values)
-```
-
-We can also include validation errors:
-
-```python
-booking, errors = BookingSchema.validate_or_error(data)
-if errors:
-    form = forms.Form(BookingSchema, values=data, errors=errors)
+form = forms.create_form(booking_schema, values=initial_values)
 ```
 
 ## Customizing field rendering

docs/json_schema.md

@@ -1,4 +1,4 @@
-TypeSystem can convert Schema classes or Field instances to/from JSON Schema.
+TypeSystem can convert Schema or Field instances to/from JSON Schema.
 
 !!! note
     TypeSystem only supports `$ref` pointers that use the standard "definitions"
@@ -15,20 +15,21 @@ Let's define a schema, and dump it out into a JSON schema document:
 import json
 import typesystem
 
-class BookingSchema(typesystem.Schema):
-    start_date = typesystem.Date(title="Start date")
-    end_date = typesystem.Date(title="End date")
-    room = typesystem.Choice(
-        title="Room type",
-        choices=[
-            ("double", "Double room"),
-            ("twin", "Twin room"),
-            ("single", "Single room"),
-        ],
-    )
-    include_breakfast = typesystem.Boolean(title="Include breakfast", default=False)
+booking_schema = typesystem.Schema(
+    fields={
+        "start_date": typesystem.Date(title="Start date"),
+        "end_date": typesystem.Date(title="End date"),
+        "room": typesystem.Choice(title="Room type", choices=[
+            ('double', 'Double room'),
+            ('twin', 'Twin room'),
+            ('single', 'Single room')
+        ]),
+        "include_breakfast": typesystem.Boolean(title="Include breakfast", default=False),
 
-schema = typesystem.to_json_schema(BookingSchema)
+    }
+)
+
+schema = typesystem.to_json_schema(booking_schema)
 print(json.dumps(schema, indent=4))
 ```
 

docs/references.md

@@ -5,72 +5,50 @@ The simplest way to use a reference, is with a schema class as a the target.
 ```python
 import typesystem
 
-class Artist(typesystem.Schema):
-    name = typesystem.String(max_length=100)
-
-class Album(typesystem.Schema):
-    title = typesystem.String(max_length=100)
-    release_date = typesystem.Date()
-    artist = typesystem.Reference(to=Artist)
-```
-
-Using a schema class directly might not always be possible. If you need to
-to support back-references or cyclical references, you can use a string-literal
-reference and provide a `SchemaDefinitions` instance, which is a dictionary-like
-object providing an index of reference lookups.
-
-```python
-import typesystem
-
-definitions = typesystem.SchemaDefinitions()
-
-class Artist(typesystem.Schema):
-    name = typesystem.String(max_length=100)
-
-class Person(typesystem.Schema):
-    name = typesystem.String(max_length=100)
-    release_date = typesystem.Date()
-    artist = typesystem.Reference(to='Artist', definitions=definitions)
-
-definitions['Artist'] = Artist
-definitions['Person'] = Person
+artist_schema = typesystem.Schema(
+    fields={
+        "name": typesystem.String(max_length=100)
+    }
+)
+
+definitions = typesystem.Definitions()
+definitions["Artist"] = artist_schema
+
+album_schema = typesystem.Schema(
+    fields={
+        "title": typesystem.String(max_length=100),
+        "release_date": typesystem.Date(),
+        "artist": typesystem.Reference(to="Artist", definitions=definitions),
+    }
+)
 ```
 
-A shorthand for including a schema class in the definitions index, and for
-setting the `definitions` on any Reference fields, is to declare schema
-classes with the `definitions` keyword argument, like so:
-
-```python
-import typesystem
-
-definitions = typesystem.SchemaDefinitions()
-
-class Artist(typesystem.Schema, definitions=definitions):
-    name = typesystem.String(max_length=100)
-
-class Person(typesystem.Schema, definitions=definitions):
-    name = typesystem.String(max_length=100)
-    release_date = typesystem.Date()
-    artist = typesystem.Reference(to='Artist')
-```
-
-Registering schema classes against a `SchemaDefinitions` instance is particularly
+Registering schema instances against a `Definitions` instance is particularly
 useful if you're using JSON schema to document the input and output types of
 a Web API, since you can easily dump all the type definitions:
 
 ```python
 import json
 import typesystem
 
-definitions = typesystem.SchemaDefinitions()
+definitions = typesystem.Definitions()
 
-class Artist(typesystem.Schema, definitions=definitions):
-    name = typesystem.String(max_length=100)
+artist_schema = typesystem.Schema(
+    fields={
+        "name": typesystem.String(max_length=100)
+    }
+)
 
-class Person(typesystem.Schema, definitions=definitions):
-    name = typesystem.String(max_length=100)
-    release_date = typesystem.Date()
-    artist = typesystem.Reference(to='Artist')
+album_schema = typesystem.Schema(
+    fields={
+        "title": typesystem.String(max_length=100),
+        "release_date": typesystem.Date(),
+        "artist": typesystem.Reference(to="Artist", definitions=definitions),
+    }
+)
+
+definitions["Artist"] = artist_schema
+definitions["Album"] = album_schema
 
 document = typesystem.to_json_schema(definitions)
 print(json.dumps(document, indent=4))
@@ -89,10 +67,10 @@ print(json.dumps(document, indent=4))
 #                 "name"
 #             ]
 #         },
-#         "Person": {
+#         "Album": {
 #             "type": "object",
 #             "properties": {
-#                 "name": {
+#                 "title": {
 #                     "type": "string",
 #                     "minLength": 1,
 #                     "maxLength": 100
@@ -107,7 +85,7 @@ print(json.dumps(document, indent=4))
 #                 }
 #             },
 #             "required": [
-#                 "name",
+#                 "title",
 #                 "release_date",
 #                 "artist"
 #             ]

docs/tokenized_errors.md

@@ -4,17 +4,21 @@ indicators showing exactly where the error occurred in the raw textual content.
 ```python
 import typesystem
 
-class Config(typesystem.Schema):
-    num_worker_processes = typesystem.Integer()
-    enable_auto_reload = typesystem.Boolean()
+
+config_schema = typesystem.Schema(
+    fields={
+        "num_worker_processes": typesystem.Integer(),
+        "enable_auto_reload": typesystem.Boolean(),
+    }
+)
 
 text = '''{
     "num_worker_processes": "x",
     "enable_auto_reload": "true"
 }'''
 
 try:
-    typesystem.validate_json(text, validator=Config)
+    typesystem.validate_json(text, validator=config_schema)
 except (typesystem.ValidationError, typesystem.ParseError) as exc:
     for message in exc.messages():
         line_no = message.start_position.line_no
@@ -28,4 +32,4 @@ The two functions for parsing content and providing positional error messages ar
 * `validate_json(text_or_bytes, validator)`
 * `validate_yaml(text_or_bytes, validator)`
 
-In both cases `validator` may either be a `Schema` class, or a `Field` instance.
+In both cases `validator` may either be a `Schema` or a `Field` instance.

scripts/check

@@ -13,4 +13,4 @@ export SOURCE_FILES="typesystem tests"
 ${PREFIX}isort --check --diff --project=typesystem $SOURCE_FILES
 ${PREFIX}black --check --diff $SOURCE_FILES
 ${PREFIX}flake8 $SOURCE_FILES
-${PREFIX}mypy
+${PREFIX}mypy typesystem

setup.cfg

@@ -5,11 +5,6 @@ max-line-length = 88
 [mypy]
 disallow_untyped_defs = True
 ignore_missing_imports = True
-files =
-  typesystem/*.py,
-  typesystem/tokenize/positional_validation.py,
-  typesystem/tokenize/tokenize_json.py,
-  typesystem/tokenize/tokens.py
 
 [tool:isort]
 profile = black

typesystem/forms.py

@@ -35,12 +35,11 @@ def __init__(
         *,
         env: "jinja2.Environment",
         schema: Schema,
-        instance: typing.Any = None,
+        values: typing.Dict[str, typing.Any] = None,
     ) -> None:
         self.env = env
         self.schema = schema
-        self.instance = instance
-        self.values = None if instance is None else self.schema.serialize(instance)
+        self.values = self.schema.serialize(values)
         self.errors: typing.Optional[typing.Dict[str, typing.Any]] = None
         self._validate_called = False
 
@@ -156,5 +155,7 @@ def load_template_env(
             )
         return jinja2.Environment(loader=loader, autoescape=True)
 
-    def create_form(self, schema: Schema, instance: typing.Any = None) -> Form:
-        return Form(env=self.env, schema=schema, instance=instance)
+    def create_form(
+        self, schema: Schema, values: typing.Dict[str, typing.Any] = None
+    ) -> Form:
+        return Form(env=self.env, schema=schema, values=values)

typesystem/tokenize/tokenize_yaml.py

@@ -53,7 +53,7 @@ def construct_sequence(loader: "yaml.Loader", node: "yaml.Node") -> ListToken:
     def construct_scalar(loader: "yaml.Loader", node: "yaml.Node") -> ScalarToken:
         start = node.start_mark.index
         end = node.end_mark.index
-        value = loader.construct_scalar(node)
+        value = loader.construct_scalar(node)  # type: ignore
         return ScalarToken(value, start, end - 1, content=str_content)
 
     def construct_int(loader: "yaml.Loader", node: "yaml.Node") -> ScalarToken:
@@ -104,14 +104,16 @@ def construct_null(loader: "yaml.Loader", node: "yaml.Node") -> ScalarToken:
         return yaml.load(str_content, CustomSafeLoader)
     except (yaml.scanner.ScannerError, yaml.parser.ParserError) as exc:  # type: ignore
         # Handle cases that result in a YAML parse error.
+        assert exc.problem is not None
+        assert exc.problem_mark is not None
         text = exc.problem + "."
         position = _get_position(str_content, index=exc.problem_mark.index)
         raise ParseError(text=text, code="parse_error", position=position)
 
 
 def validate_yaml(
     content: typing.Union[str, bytes],
-    validator: typing.Union[Field, typing.Type[Schema]],
+    validator: typing.Union[Field, Schema],
 ) -> typing.Any:
     """
     Parse and validate a YAML string, returning positionally marked error