SimpleΒΆ
To illustrate the purpose of the OpenAlchemy package, the following example OpenAPI specification defines an endpoint to retrieve the employees of a company:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | openapi: "3.0.0"
info:
title: Test Schema
description: API to illustrate OpenAlchemy MVP.
version: "0.1"
paths:
/employee:
get:
summary: Used to retrieve all employees.
responses:
200:
description: Return all employees from the database.
content:
application/json:
schema:
type: array
items:
"$ref": "#/components/schemas/Employee"
components:
schemas:
Employee:
description: Person that works for a company.
type: object
x-tablename: employee
properties:
id:
type: integer
description: Unique identifier for the employee.
example: 0
x-primary-key: true
x-autoincrement: true
name:
type: string
description: The name of the employee.
example: David Andersson
x-index: true
division:
type: string
description: The part of the company the employee works in.
example: Engineering
x-index: true
salary:
type: number
description: The amount of money the employee is paid.
example: 1000000.00
required:
- name
- division
|
It is common to store data to fulfill such an endpoint in a database, for which OpenAlchemy can be used to re-use the schemas from the OpenAPI specification to define the database schemas with the help of certain extension properties.
See also
The following example models file makes use of the OpenAPI specification to define the SQLAlchemy models:
1 2 3 | from open_alchemy import init_yaml
init_yaml("example-spec.yml", models_filename="models_auto.py")
|
This models file instructs OpenAlchemy to construct the SQLAlchemy models equivalent to the following traditional SQLAlchemy models.py file:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class Employee(Base):
"""Person that works for a company."""
__tablename__ = "employee"
id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
name = sa.Column(sa.String, index=True)
division = sa.Column(sa.String, index=True)
salary = sa.Column(sa.Float)
|
OpenAlchemy also generates a fully type hinted version of the generated SQLAlchemy models:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 | """Autogenerated SQLAlchemy models based on OpenAlchemy models."""
# pylint: disable=no-member,super-init-not-called,unused-argument
import typing
import sqlalchemy
from sqlalchemy import orm
from open_alchemy import models
Base = models.Base # type: ignore
class _EmployeeDictBase(typing.TypedDict, total=True):
"""TypedDict for properties that are required."""
name: str
division: str
class EmployeeDict(_EmployeeDictBase, total=False):
"""TypedDict for properties that are not required."""
id: int
salary: typing.Optional[float]
class TEmployee(typing.Protocol):
"""
SQLAlchemy model protocol.
Person that works for a company.
Attrs:
id: Unique identifier for the employee.
name: The name of the employee.
division: The part of the company the employee works in.
salary: The amount of money the employee is paid.
"""
# SQLAlchemy properties
__table__: sqlalchemy.Table
__tablename__: str
query: orm.Query
# Model properties
id: "sqlalchemy.Column[int]"
name: "sqlalchemy.Column[str]"
division: "sqlalchemy.Column[str]"
salary: "sqlalchemy.Column[typing.Optional[float]]"
def __init__(
self,
name: str,
division: str,
id: typing.Optional[int] = None,
salary: typing.Optional[float] = None,
) -> None:
"""
Construct.
Args:
id: Unique identifier for the employee.
name: The name of the employee.
division: The part of the company the employee works in.
salary: The amount of money the employee is paid.
"""
...
@classmethod
def from_dict(
cls,
name: str,
division: str,
id: typing.Optional[int] = None,
salary: typing.Optional[float] = None,
) -> "TEmployee":
"""
Construct from a dictionary (eg. a POST payload).
Args:
id: Unique identifier for the employee.
name: The name of the employee.
division: The part of the company the employee works in.
salary: The amount of money the employee is paid.
Returns:
Model instance based on the dictionary.
"""
...
@classmethod
def from_str(cls, value: str) -> "TEmployee":
"""
Construct from a JSON string (eg. a POST payload).
Returns:
Model instance based on the JSON string.
"""
...
def to_dict(self) -> EmployeeDict:
"""
Convert to a dictionary (eg. to send back for a GET request).
Returns:
Dictionary based on the model instance.
"""
...
def to_str(self) -> str:
"""
Convert to a JSON string (eg. to send back for a GET request).
Returns:
JSON string based on the model instance.
"""
...
Employee: typing.Type[TEmployee] = models.Employee # type: ignore
|
This allows for autocomplete on the model initialization:
and it also enables autocomplete on instance variables:
See also