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