coloco 0.4.4__tar.gz → 0.4.6__tar.gz

{coloco-0.4.4 → coloco-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coloco
-Version: 0.4.4
+Version: 0.4.6
 Summary: A kit for creating FastAPI + Svelte applications
 Author-Email: Channel Cat <channelcat@gmail.com>
 License: MIT

{coloco-0.4.4 → coloco-0.4.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "coloco"
-version = "0.4.4"
+version = "0.4.6"
 description = "A kit for creating FastAPI + Svelte applications"
 authors = [
     { name = "Channel Cat", email = "channelcat@gmail.com" },

{coloco-0.4.4 → coloco-0.4.6}/src/coloco/api.py

@@ -87,12 +87,12 @@ def create_api(is_dev: bool = False):
 global_routes: list[ColocoRoute] = []
 
 
-def api(func):
+def api(func: T) -> T:
     # Auto-route
     return _add_global_route([f"/{func.__name__}"], {}, func, "GET")
 
 
-def _add_global_route(args, kwargs, func, method: str):
+def _add_global_route(args, kwargs, func: T, method: str) -> T:
     module_name = func.__module__.lstrip("src.app")
 
     # Prepend module name to path
@@ -113,7 +113,9 @@ def _add_global_route(args, kwargs, func, method: str):
     else:
         kwargs["path"] = path
 
-    return global_routes.append(ColocoRoute(args, kwargs, func, method, module_name))
+    global_routes.append(ColocoRoute(args, kwargs, func, method, module_name))
+
+    return func
 
 
 def _make_route_decorator(method: str) -> Callable[..., Callable[[T], T]]:

{coloco-0.4.4 → coloco-0.4.6}/src/coloco/app.py

@@ -1,6 +1,7 @@
 from .api import create_api, global_routes
 from dataclasses import dataclass
 from .db import (
+    create_model_serializers,
     get_orm_config,
     inject_model_serializers,
     register_db_lifecycle,
@@ -71,10 +72,6 @@ def create_app(name: str, database_url: str = None) -> ColocoApp:
             print(traceback.format_exc())
             continue
 
-    # Inject type hints
-    for route in global_routes:
-        fill_type_hints(route.func, use_literals=True)
-
     # Setup Database
     # We need this first to grab the models for route type hints
     has_database = bool(database_url)
@@ -83,10 +80,18 @@ def create_app(name: str, database_url: str = None) -> ColocoApp:
             database_url,
             model_files=discover_files(src_path, name="models.py", is_dev=mode == "dev"),
         )
-        inject_model_serializers(orm_config, global_routes)
+        model_to_serializer = create_model_serializers(orm_config)
     else:
         orm_config = None
 
+    # Inject type hints
+    for route in global_routes:
+        fill_type_hints(route.func, use_literals=True)
+
+    # Inject model serializers after type hints
+    if has_database:
+        inject_model_serializers(model_to_serializer, global_routes)
+
     router = APIRouter()
     for route in global_routes:
         router.api_route(

{coloco-0.4.4 → coloco-0.4.6}/src/coloco/cli/db.py

@@ -40,8 +40,11 @@ def db_command(func):
     def wrapper(*args, **kwargs):
         tortoise_logger.setLevel(logging.WARNING)
         run(func(*args, **kwargs))
-        # TODO: figure out why the event loop is closed already when using postgres
-        # run(Tortoise.close_connections())
+        try:
+            run(Tortoise.close_connections())
+        except RuntimeError:
+            # TODO: figure out why the event loop is closed already when using postgres
+            pass
 
     return app.command(name=func.__name__)(wrapper)
 

{coloco-0.4.4 → coloco-0.4.6}/src/coloco/db.py

@@ -1,12 +1,14 @@
 from .api import ColocoRoute
 from contextlib import asynccontextmanager
 from collections import defaultdict
+from copy import copy
 from functools import wraps
 from .lifespan import register_lifespan
 from rich import print
+from tortoise.fields import Field
 from type_less import replace_type_hint_map_deep
-from typing import TypeVar
-
+from typing import *
+import datetime
 
 CLS = TypeVar("CLS")
 
@@ -76,7 +78,7 @@ def register_db_lifecycle(app):
     register_lifespan(lifecycle_connect_database)
 
 
-def inject_model_serializers(orm_config: dict, routes: list[ColocoRoute]):
+def create_model_serializers(orm_config: dict):
     try:
         from tortoise import Tortoise
         from tortoise.contrib.pydantic import pydantic_model_creator
@@ -99,14 +101,25 @@ def inject_model_serializers(orm_config: dict, routes: list[ColocoRoute]):
     for model_class in model_classes:
         # Wrapped with @serializable
         if getattr(model_class, "__model_serializer_create", None):
-            model_class.__model_serializer = pydantic_model_creator(
+            model_to_serializer[model_class] = pydantic_model_creator(
                 model_class, **model_class.__model_serializer_create
             )
         # Create a general serializer
-        elif not getattr(model_class, "__model_serializer", None):
-            model_class.__model_serializer = pydantic_model_creator(model_class)
-        model_to_serializer[model_class] = model_class.__model_serializer
+        elif not model_class in model_to_serializer:
+            model_to_serializer[model_class] = pydantic_model_creator(model_class)
+
+        # Inject type annotations into model
+        # TODO: find a better way to do this that's less dependent on Tortoise internals
+        description = model_class.describe(serializable=False)
+        fields = [*description["data_fields"], description["pk_field"]]
+        for field in fields:
+            if field["name"] not in model_class.__annotations__:
+                model_class.__annotations__[field["name"]] = field["python_type"]
+
+    return model_to_serializer
+
 
+def inject_model_serializers(model_to_serializer: dict, routes: list[ColocoRoute]):
     for route in routes:
         route.func.__annotations__["return"], occurrences = replace_type_hint_map_deep(
             route.func.__annotations__["return"],
@@ -120,25 +133,25 @@ def inject_model_serializers(orm_config: dict, routes: list[ColocoRoute]):
         # - Pydantic - sync serialization only
         # - JSON Encoder - sync serialization only, + happens after serialization
         if occurrences:
-            route.func = _wrap_model_serializer(route.func)
+            route.func = _wrap_model_serializer(route.func, model_to_serializer)
 
 
-async def _serialize_models(obj):
+async def _serialize_models(obj, model_to_serializer):
     """
     Auto-runs the serializer for tortoise models
     """
-    if hasattr(obj, "__model_serializer"):
-        return await obj.__model_serializer.from_tortoise_orm(obj)
+    if type(obj) in model_to_serializer:
+        return await model_to_serializer[type(obj)].from_tortoise_orm(obj)
     elif isinstance(obj, list):
-        return [await _serialize_models(item) for item in obj]
+        return [await _serialize_models(item, model_to_serializer) for item in obj]
     elif isinstance(obj, dict):
-        return {k: await _serialize_models(v) for k, v in obj.items()}
+        return {k: await _serialize_models(v, model_to_serializer) for k, v in obj.items()}
     return obj
 
 
-def _wrap_model_serializer(func):
+def _wrap_model_serializer(func, model_to_serializer):
     @wraps(func)
     async def wrapper(*args, **kwargs):
-        return await _serialize_models(await func(*args, **kwargs))
+        return await _serialize_models(await func(*args, **kwargs), model_to_serializer)
 
     return wrapper