Skip to content

Handlers

lightapi.handlers

Attributes

Classes

AbstractHandler dataclass

Bases: ABC

Abstract base class for handling HTTP requests related to a specific model.

Attributes:

Name Type Description
model Base

The SQLAlchemy model class to operate on.
Source code in lightapi/handlers.py 
 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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
@dataclass
class AbstractHandler(ABC):
    """
    Abstract base class for handling HTTP requests related to a specific model.

    Attributes:
        model (Base): The SQLAlchemy model class to operate on.
    """

    model: Type[Base] = field(default=None)

    @abstractmethod
    async def handle(self, db: Session, request: web.Request):
        """
        Abstract method to handle the HTTP request.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Raises:
            NotImplementedError: If the method is not implemented by subclasses.
        """
        raise NotImplementedError("Method not implemented")

    async def __call__(self, request: web.Request, *args, **kwargs):
        """
        Calls the handler with the provided request.

        Args:
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: The response returned by the handler.
        """
        db: Session = SessionLocal()
        try:
            return await self.handle(db, request)
        finally:
            db.close()

    async def get_request_json(self, request: web.Request):
        """
        Extracts JSON data from the request body.

        Args:
            request (web.Request): The aiohttp web request object.

        Returns:
            dict: The JSON data from the request body.
        """
        return await request.json()

    def get_item_by_id(self, db: Session, item_id: int):
        """
        Retrieves an item by its primary key.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            item_id (int): The primary key of the item to retrieve.

        Returns:
            Base: The item retrieved from the database, or None if not found.
        """
        return db.query(self.model).filter(self.model.pk == item_id).first()

    def add_and_commit_item(self, db: Session, item):
        """
        Adds and commits a new item to the database.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            item (Base): The item to add and commit.

        Returns:
            Base: The item after committing to the database.
        """
        db.add(item)
        db.commit()
        db.refresh(item)
        return item

    def delete_and_commit_item(self, db: Session, item):
        """
        Deletes and commits the removal of an item from the database.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            item (Base): The item to delete.
        """
        db.delete(item)
        db.commit()

    def json_response(self, item, status=200):
        """
        Creates a JSON response for the given item.

        Args:
            item (Base): The item to serialize and return.
            status (int, optional): The HTTP status code. Defaults to 200.

        Returns:
            web.Response: The JSON response containing the serialized item.
        """
        return web.json_response(item.serialize(), status=status)

    def json_error_response(self, error_message, status=404):
        """
        Creates a JSON response for an error message.

        Args:
            error_message (str): The error message to return.
            status (int, optional): The HTTP status code. Defaults to 404.

        Returns:
            web.Response: The JSON response containing the error message.
        """
        return web.json_response({'error': error_message}, status=status)
Attributes
model class-attribute instance-attribute 
model: Type[Base] = field(default=None)
Functions
__init__ 
__init__(model: Type[Base] = None) -> None
handle abstractmethod async 
handle(db: Session, request: Request)

Abstract method to handle the HTTP request.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Raises:

Type Description
NotImplementedError

If the method is not implemented by subclasses.
Source code in lightapi/handlers.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
@abstractmethod
async def handle(self, db: Session, request: web.Request):
    """
    Abstract method to handle the HTTP request.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Raises:
        NotImplementedError: If the method is not implemented by subclasses.
    """
    raise NotImplementedError("Method not implemented")
__call__ async 
__call__(request: Request, *args, **kwargs)

Calls the handler with the provided request.

Parameters:

Name Type Description Default
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: The response returned by the handler.
Source code in lightapi/handlers.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
async def __call__(self, request: web.Request, *args, **kwargs):
    """
    Calls the handler with the provided request.

    Args:
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: The response returned by the handler.
    """
    db: Session = SessionLocal()
    try:
        return await self.handle(db, request)
    finally:
        db.close()
get_request_json async 
get_request_json(request: Request)

Extracts JSON data from the request body.

Parameters:

Name Type Description Default
request Request

The aiohttp web request object.

 required

Returns:

Name Type Description
dict

The JSON data from the request body.
Source code in lightapi/handlers.py 
73
74
75
76
77
78
79
80
81
82
83
async def get_request_json(self, request: web.Request):
    """
    Extracts JSON data from the request body.

    Args:
        request (web.Request): The aiohttp web request object.

    Returns:
        dict: The JSON data from the request body.
    """
    return await request.json()
get_item_by_id 
get_item_by_id(db: Session, item_id: int)

Retrieves an item by its primary key.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
item_id int

The primary key of the item to retrieve.

 required

Returns:

Name Type Description
Base

The item retrieved from the database, or None if not found.
Source code in lightapi/handlers.py 
85
86
87
88
89
90
91
92
93
94
95
96
def get_item_by_id(self, db: Session, item_id: int):
    """
    Retrieves an item by its primary key.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        item_id (int): The primary key of the item to retrieve.

    Returns:
        Base: The item retrieved from the database, or None if not found.
    """
    return db.query(self.model).filter(self.model.pk == item_id).first()
add_and_commit_item 
add_and_commit_item(db: Session, item)

Adds and commits a new item to the database.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
item Base

The item to add and commit.

 required

Returns:

Name Type Description
Base

The item after committing to the database.
Source code in lightapi/handlers.py 
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def add_and_commit_item(self, db: Session, item):
    """
    Adds and commits a new item to the database.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        item (Base): The item to add and commit.

    Returns:
        Base: The item after committing to the database.
    """
    db.add(item)
    db.commit()
    db.refresh(item)
    return item
delete_and_commit_item 
delete_and_commit_item(db: Session, item)

Deletes and commits the removal of an item from the database.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
item Base

The item to delete.

 required
Source code in lightapi/handlers.py 
114
115
116
117
118
119
120
121
122
123
def delete_and_commit_item(self, db: Session, item):
    """
    Deletes and commits the removal of an item from the database.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        item (Base): The item to delete.
    """
    db.delete(item)
    db.commit()
json_response 
json_response(item, status=200)

Creates a JSON response for the given item.

Parameters:

Name Type Description Default
item Base

The item to serialize and return.

 required
status int

The HTTP status code. Defaults to 200.

 200

Returns:

Type Description

web.Response: The JSON response containing the serialized item.
Source code in lightapi/handlers.py 
125
126
127
128
129
130
131
132
133
134
135
136
def json_response(self, item, status=200):
    """
    Creates a JSON response for the given item.

    Args:
        item (Base): The item to serialize and return.
        status (int, optional): The HTTP status code. Defaults to 200.

    Returns:
        web.Response: The JSON response containing the serialized item.
    """
    return web.json_response(item.serialize(), status=status)
json_error_response 
json_error_response(error_message, status=404)

Creates a JSON response for an error message.

Parameters:

Name Type Description Default
error_message str

The error message to return.

 required
status int

The HTTP status code. Defaults to 404.

 404

Returns:

Type Description

web.Response: The JSON response containing the error message.
Source code in lightapi/handlers.py 
138
139
140
141
142
143
144
145
146
147
148
149
def json_error_response(self, error_message, status=404):
    """
    Creates a JSON response for an error message.

    Args:
        error_message (str): The error message to return.
        status (int, optional): The HTTP status code. Defaults to 404.

    Returns:
        web.Response: The JSON response containing the error message.
    """
    return web.json_response({'error': error_message}, status=status)

CreateHandler dataclass

Bases: AbstractHandler

Handles HTTP POST requests to create a new item.

Source code in lightapi/handlers.py 
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
class CreateHandler(AbstractHandler):
    """
    Handles HTTP POST requests to create a new item.
    """

    async def handle(self, db, request):
        """
        Processes the POST request to create and save a new item.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: The JSON response containing the created item.
        """
        data = await self.get_request_json(request)
        item = self.model(**data)
        item = self.add_and_commit_item(db, item)
        return self.json_response(item, status=201)
Functions
handle async 
handle(db, request)

Processes the POST request to create and save a new item.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: The JSON response containing the created item.
Source code in lightapi/handlers.py 
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
async def handle(self, db, request):
    """
    Processes the POST request to create and save a new item.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: The JSON response containing the created item.
    """
    data = await self.get_request_json(request)
    item = self.model(**data)
    item = self.add_and_commit_item(db, item)
    return self.json_response(item, status=201)

ReadHandler dataclass

Bases: AbstractHandler

Handles HTTP GET requests to retrieve one or all items.

Source code in lightapi/handlers.py 
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
class ReadHandler(AbstractHandler):
    """
    Handles HTTP GET requests to retrieve one or all items.
    """

    async def handle(self, db, request):
        """
        Processes the GET request to retrieve an item by ID or all items.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: The JSON response containing the item(s) or an error message.
        """
        if 'id' not in request.match_info:
            items = db.query(self.model).all()
            response = [item.serialize() for item in items]
            return self.json_response(response, status=200)
        else:
            item_id = int(request.match_info['id'])
            item = self.get_item_by_id(db, item_id)
            if item:
                return self.json_response(item, status=200)
            else:
                return self.json_error_response('Item not found', status=404)
Functions
handle async 
handle(db, request)

Processes the GET request to retrieve an item by ID or all items.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: The JSON response containing the item(s) or an error message.
Source code in lightapi/handlers.py 
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
async def handle(self, db, request):
    """
    Processes the GET request to retrieve an item by ID or all items.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: The JSON response containing the item(s) or an error message.
    """
    if 'id' not in request.match_info:
        items = db.query(self.model).all()
        response = [item.serialize() for item in items]
        return self.json_response(response, status=200)
    else:
        item_id = int(request.match_info['id'])
        item = self.get_item_by_id(db, item_id)
        if item:
            return self.json_response(item, status=200)
        else:
            return self.json_error_response('Item not found', status=404)

UpdateHandler dataclass

Bases: AbstractHandler

Handles HTTP PUT requests to update an existing item.

Source code in lightapi/handlers.py 
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
class UpdateHandler(AbstractHandler):
    """
    Handles HTTP PUT requests to update an existing item.
    """

    async def handle(self, db, request):
        """
        Processes the PUT request to update an existing item.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: The JSON response containing the updated item or an error message.
        """
        item_id = int(request.match_info['id'])
        item = self.get_item_by_id(db, item_id)
        if not item:
            return self.json_error_response('Item not found', status=404)

        data = await self.get_request_json(request)
        for key, value in data.items():
            setattr(item, key, value)

        item = self.add_and_commit_item(db, item)
        return self.json_response(item, status=200)
Functions
handle async 
handle(db, request)

Processes the PUT request to update an existing item.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: The JSON response containing the updated item or an error message.
Source code in lightapi/handlers.py 
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
async def handle(self, db, request):
    """
    Processes the PUT request to update an existing item.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: The JSON response containing the updated item or an error message.
    """
    item_id = int(request.match_info['id'])
    item = self.get_item_by_id(db, item_id)
    if not item:
        return self.json_error_response('Item not found', status=404)

    data = await self.get_request_json(request)
    for key, value in data.items():
        setattr(item, key, value)

    item = self.add_and_commit_item(db, item)
    return self.json_response(item, status=200)

PatchHandler dataclass

Bases: AbstractHandler

Handles HTTP PATCH requests to partially update an existing item.

Source code in lightapi/handlers.py 
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
class PatchHandler(AbstractHandler):
    """
    Handles HTTP PATCH requests to partially update an existing item.
    """

    async def handle(self, db, request):
        """
        Processes the PATCH request to partially update an existing item.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: The JSON response containing the updated item or an error message.
        """
        item_id = int(request.match_info['id'])
        item = self.get_item_by_id(db, item_id)
        if not item:
            return self.json_error_response('Item not found', status=404)

        data = await self.get_request_json(request)
        for key, value in data.items():
            setattr(item, key, value)

        item = self.add_and_commit_item(db, item)
        return self.json_response(item, status=200)
Functions
handle async 
handle(db, request)

Processes the PATCH request to partially update an existing item.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: The JSON response containing the updated item or an error message.
Source code in lightapi/handlers.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
async def handle(self, db, request):
    """
    Processes the PATCH request to partially update an existing item.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: The JSON response containing the updated item or an error message.
    """
    item_id = int(request.match_info['id'])
    item = self.get_item_by_id(db, item_id)
    if not item:
        return self.json_error_response('Item not found', status=404)

    data = await self.get_request_json(request)
    for key, value in data.items():
        setattr(item, key, value)

    item = self.add_and_commit_item(db, item)
    return self.json_response(item, status=200)

DeleteHandler dataclass

Bases: AbstractHandler

Handles HTTP DELETE requests to delete an existing item.

Source code in lightapi/handlers.py 
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
class DeleteHandler(AbstractHandler):
    """
    Handles HTTP DELETE requests to delete an existing item.
    """

    async def handle(self, db, request):
        """
        Processes the DELETE request to remove an existing item.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: An empty response with status 204 if the item is deleted.
        """
        item_id = int(request.match_info['id'])
        item = self.get_item_by_id(db, item_id)
        if not item:
            return self.json_error_response('Item not found', status=404)

        self.delete_and_commit_item(db, item)
        return web.Response(status=204)
Functions
handle async 
handle(db, request)

Processes the DELETE request to remove an existing item.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: An empty response with status 204 if the item is deleted.
Source code in lightapi/handlers.py 
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
async def handle(self, db, request):
    """
    Processes the DELETE request to remove an existing item.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: An empty response with status 204 if the item is deleted.
    """
    item_id = int(request.match_info['id'])
    item = self.get_item_by_id(db, item_id)
    if not item:
        return self.json_error_response('Item not found', status=404)

    self.delete_and_commit_item(db, item)
    return web.Response(status=204)

RetrieveAllHandler dataclass

Bases: AbstractHandler

Handles HTTP GET requests to retrieve all items.

Source code in lightapi/handlers.py 
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
class RetrieveAllHandler(AbstractHandler):
    """
    Handles HTTP GET requests to retrieve all items.
    """

    async def handle(self, db, request):
        """
        Processes the GET request to retrieve all items.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: The JSON response containing all items.
        """
        items = db.query(self.model).all()
        response = [item.serialize() for item in items]
        return web.json_response(response, status=200)
Functions
handle async 
handle(db, request)

Processes the GET request to retrieve all items.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: The JSON response containing all items.
Source code in lightapi/handlers.py 
291
292
293
294
295
296
297
298
299
300
301
302
303
304
async def handle(self, db, request):
    """
    Processes the GET request to retrieve all items.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: The JSON response containing all items.
    """
    items = db.query(self.model).all()
    response = [item.serialize() for item in items]
    return web.json_response(response, status=200)

OptionsHandler dataclass

Bases: AbstractHandler

Handles HTTP OPTIONS requests to provide allowed methods and headers.

Source code in lightapi/handlers.py 
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
class OptionsHandler(AbstractHandler):
    """
    Handles HTTP OPTIONS requests to provide allowed methods and headers.
    """

    async def handle(self, db, request):
        """
        Processes the OPTIONS request to provide allowed methods and headers.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: The JSON response containing allowed methods and headers.
        """
        return web.json_response(
            {
                'allowed_methods': [
                    'GET',
                    'POST',
                    'PUT',
                    'DELETE',
                    'PATCH',
                    'OPTIONS',
                    'HEAD',
                ],
                'allowed_headers': ['Content-Type', 'Authorization'],
                'max_age': 3600,
            }
        )
Functions
handle async 
handle(db, request)

Processes the OPTIONS request to provide allowed methods and headers.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: The JSON response containing allowed methods and headers.
Source code in lightapi/handlers.py 
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
async def handle(self, db, request):
    """
    Processes the OPTIONS request to provide allowed methods and headers.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: The JSON response containing allowed methods and headers.
    """
    return web.json_response(
        {
            'allowed_methods': [
                'GET',
                'POST',
                'PUT',
                'DELETE',
                'PATCH',
                'OPTIONS',
                'HEAD',
            ],
            'allowed_headers': ['Content-Type', 'Authorization'],
            'max_age': 3600,
        }
    )

HeadHandler dataclass

Bases: AbstractHandler

Handles HTTP HEAD requests to check the resource existence.

Source code in lightapi/handlers.py 
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
class HeadHandler(AbstractHandler):
    """
    Handles HTTP HEAD requests to check the resource existence.
    """

    async def handle(self, db, request):
        """
        Processes the HEAD request to check the resource existence.

        Args:
            db (Session): The SQLAlchemy session for database operations.
            request (web.Request): The aiohttp web request object.

        Returns:
            web.Response: An empty response with status 200.
        """
        return web.Response(status=200, headers={'Content-Type': 'application/json'})
Functions
handle async 
handle(db, request)

Processes the HEAD request to check the resource existence.

Parameters:

Name Type Description Default
db Session

The SQLAlchemy session for database operations.

 required
request Request

The aiohttp web request object.

 required

Returns:

Type Description

web.Response: An empty response with status 200.
Source code in lightapi/handlers.py 
345
346
347
348
349
350
351
352
353
354
355
356
async def handle(self, db, request):
    """
    Processes the HEAD request to check the resource existence.

    Args:
        db (Session): The SQLAlchemy session for database operations.
        request (web.Request): The aiohttp web request object.

    Returns:
        web.Response: An empty response with status 200.
    """
    return web.Response(status=200, headers={'Content-Type': 'application/json'})

Functions

create_handler 

create_handler(model: Type[Base]) -> List[RouteDef]

Creates a list of route handlers for the given model.

Parameters:

Name Type Description Default
model Base

The SQLAlchemy model class for which to create handlers.

 required

Returns:

Name Type Description
list List[RouteDef]

A list of aiohttp web routes for the specified model.
Source code in lightapi/handlers.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def create_handler(model: Type[Base]) -> List[web.RouteDef]:
    """
    Creates a list of route handlers for the given model.

    Args:
        model (Base): The SQLAlchemy model class for which to create handlers.

    Returns:
        list: A list of aiohttp web routes for the specified model.
    """
    return [
        web.post(f'/{model.__tablename__}/', CreateHandler(model)),
        web.get(f'/{model.__tablename__}/', RetrieveAllHandler(model)),
        web.get(f'/{model.__tablename__}/{{id}}', ReadHandler(model)),
        web.put(f'/{model.__tablename__}/{{id}}', UpdateHandler(model)),
        web.delete(f'/{model.__tablename__}/{{id}}', DeleteHandler(model)),
        web.patch(f'/{model.__tablename__}/{{id}}', PatchHandler(model)),
        web.options(f'/{model.__tablename__}/', OptionsHandler(model)),
        web.head(f'/{model.__tablename__}/', HeadHandler(model)),
    ]