coloco 0.3.4__tar.gz → 0.3.5__tar.gz

{coloco-0.3.4 → coloco-0.3.5}/PKG-INFO

@@ -1,17 +1,17 @@
 Metadata-Version: 2.1
 Name: coloco
-Version: 0.3.4
+Version: 0.3.5
 Summary: A kit for creating FastAPI + Svelte applications
 Author-Email: Channel Cat <channelcat@gmail.com>
 License: MIT
 Requires-Python: >=3.11
-Requires-Dist: aerich[toml]==0.8.1
-Requires-Dist: fastapi==0.115.0
-Requires-Dist: PyJWT==2.10.1
-Requires-Dist: tortoise-orm[asyncpg]==0.24.0
+Requires-Dist: aerich[toml]>=0.8.1
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: PyJWT>=2.10.1
+Requires-Dist: tortoise-orm[asyncpg]>=0.24.0
 Requires-Dist: type-less>=0.1.8
-Requires-Dist: typer==0.15.2
-Requires-Dist: uvicorn==0.31.0
+Requires-Dist: typer>=0.15.2
+Requires-Dist: uvicorn>=0.31.0
 Description-Content-Type: text/markdown
 
 # Coloco
@@ -56,8 +56,8 @@ Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=Coloco
 # Running in Production
 
 - `coloco build`
-
-- `coloco serve`
+- Artifacts will be saved to `dist`
+- From dist, run `coloco serve`
 
 # Opinions
 
@@ -72,9 +72,11 @@ This framework is opinionated and combines the following excellent tools:
 # Plans
 
 - Deploy tools
-- ORM Support
-- SQLite/Postgres support
+- Migrations for ORM - `aerich` (Improvements needed, watching `tortoise-pathway`)
+- CRUD
+- Caching
 - Package/share modules with git
+- 
 
 # Dreams
 

{coloco-0.3.4 → coloco-0.3.5}/README.md

@@ -40,8 +40,8 @@ Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=Coloco
 # Running in Production
 
 - `coloco build`
-
-- `coloco serve`
+- Artifacts will be saved to `dist`
+- From dist, run `coloco serve`
 
 # Opinions
 
@@ -56,9 +56,11 @@ This framework is opinionated and combines the following excellent tools:
 # Plans
 
 - Deploy tools
-- ORM Support
-- SQLite/Postgres support
+- Migrations for ORM - `aerich` (Improvements needed, watching `tortoise-pathway`)
+- CRUD
+- Caching
 - Package/share modules with git
+- 
 
 # Dreams
 

{coloco-0.3.4 → coloco-0.3.5}/pyproject.toml

@@ -1,18 +1,18 @@
 [project]
 name = "coloco"
-version = "0.3.4"
+version = "0.3.5"
 description = "A kit for creating FastAPI + Svelte applications"
 authors = [
     { name = "Channel Cat", email = "channelcat@gmail.com" },
 ]
 dependencies = [
-    "aerich[toml]==0.8.1",
-    "fastapi==0.115.0",
-    "PyJWT==2.10.1",
-    "tortoise-orm[asyncpg]==0.24.0",
+    "aerich[toml]>=0.8.1",
+    "fastapi>=0.115.0",
+    "PyJWT>=2.10.1",
+    "tortoise-orm[asyncpg]>=0.24.0",
     "type-less>=0.1.8",
-    "typer==0.15.2",
-    "uvicorn==0.31.0",
+    "typer>=0.15.2",
+    "uvicorn>=0.31.0",
 ]
 requires-python = ">=3.11"
 readme = "README.md"

{coloco-0.3.4 → coloco-0.3.5}/src/coloco/__init__.py

@@ -1,12 +1,16 @@
-from .app import create_app
+from .api import api
+from .app import ColocoApp, create_app, get_current_app
 from .codegen import generate_openapi_schema, generate_openapi_code
 from .exceptions import UserError
-from .api import api
+from . import dependencies
 
 __all__ = [
     "api",
+    "ColocoApp",
     "create_app",
+    "dependencies",
     "generate_openapi_schema",
     "generate_openapi_code",
+    "get_current_app",
     "UserError",
 ]

{coloco-0.3.4 → coloco-0.3.5}/src/coloco/api.py

@@ -18,6 +18,8 @@ logging.basicConfig(level=logging.INFO)
 
 
 def _generate_openapi_thread(app: FastAPI):
+    # TODO: diff check the schema json
+    # TODO: diff check not working
     logging.info("Generating OpenAPI schema in thread...")
     generate_openapi_schema(app)
     generate_openapi_code(host=f"http://localhost:5172", diff_files=True)
@@ -87,7 +89,10 @@ def _add_global_route(args, kwargs, func, method: str):
         # TODO: Make this configurable
         "/api/"
         # TODO: Make this read project configuration, probably need to add routes after running
-        + module_name.rsplit(".", 1)[0].replace(".", "/")
+        + module_name.rsplit(".", 1)[0]
+        .replace(".", "/")
+        .replace(".-", ".")  # Strip - from folders (for dev only)
+        .lstrip("-")
         + ("" if path.startswith("/") else "/")
         + path
     )

{coloco-0.3.4 → coloco-0.3.5}/src/coloco/app.py

@@ -1,6 +1,6 @@
 from .api import create_api, global_router
 from dataclasses import dataclass
-from .db import get_orm_config, lifecycle_connect_database
+from .db import get_orm_config, create_lifecycle_connect_database
 from fastapi import FastAPI
 from importlib import import_module
 from .lifespan import register_lifespan
@@ -17,10 +17,10 @@ class ColocoApp:
     name: str
     database_url: str = None
     orm_config: dict = None
-    migrations_dir: str = "./+migrations"
+    migrations_dir: str = "+migrations"
 
 
-def discover_files(directory, name):
+def discover_files(directory, name, is_dev=False):
     api_files = []
     try:
         with os.scandir(directory) as entries:
@@ -29,12 +29,12 @@ def discover_files(directory, name):
                     # Skip directories starting with "+" and "node_modules"
                     if (
                         not entry.name.startswith("+")
-                        and not entry.name.startswith("-")
+                        and (not entry.name.startswith("-") or is_dev)
                         and not entry.name.startswith(".")
                         and not entry.name == "node_modules"
                         and not entry.name == "coloco"
                     ):
-                        api_files.extend(discover_files(entry.path, name))
+                        api_files.extend(discover_files(entry.path, name, is_dev))
                 elif entry.is_file() and entry.name == name:
                     api_files.append(entry.path)
     except (PermissionError, FileNotFoundError) as e:
@@ -54,7 +54,7 @@ def create_app(name: str, database_url: str = None) -> ColocoApp:
     api = create_api(is_dev=mode == "dev")
 
     # Discover all api.py files from root, excluding node_modules and +app
-    api_files = discover_files(".", name="api.py")
+    api_files = discover_files(".", name="api.py", is_dev=mode == "dev")
     for api_file in api_files:
         # convert python file path to module path
         module_name = api_file.replace("./", "").replace(".py", "").replace("/", ".")
@@ -74,15 +74,19 @@ def create_app(name: str, database_url: str = None) -> ColocoApp:
     # Setup Database
     if database_url:
         orm_config = get_orm_config(
-            database_url, model_files=discover_files(".", name="models.py")
+            database_url,
+            model_files=discover_files(".", name="models.py", is_dev=mode == "dev"),
         )
-        register_lifespan(lifecycle_connect_database)
     else:
         orm_config = None
 
     CURRENT_APP = ColocoApp(
         api=api, name=name, database_url=database_url, orm_config=orm_config
     )
+
+    if database_url:
+        register_lifespan(create_lifecycle_connect_database(CURRENT_APP))
+
     return CURRENT_APP
 
 

coloco-0.3.5/src/coloco/cli/db.py

@@ -0,0 +1,252 @@
+import aerich
+import aerich.migrate
+
+from aerich import Command
+from aerich.models import Aerich
+from aerich.migrate import Migrate
+from aerich.utils import get_app_connection, get_models_describe
+from .api import _verify_app
+from ..app import ColocoApp, get_current_app
+from ..db import app_class_to_table_name
+from asyncio import run
+import functools
+import os
+from pathlib import Path
+from rich import print
+
+from tortoise import generate_schema_for_client, Tortoise
+from tortoise.exceptions import OperationalError
+import typer
+
+
+app = typer.Typer()
+
+# ----------------------------- Monkey Patching -----------------------------
+# TODO: Propose a patch to aerich to make migration location more configurable
+_monkey_patched = False
+
+
+def patch_migration_location(migrations_dir: str):
+    global _monkey_patched
+    if not _monkey_patched:
+
+        def patched_path(*args, **kwargs):
+            if len(args) == 2 and args[0] == migrations_dir:
+                return Path("src", "app", args[1], args[0], **kwargs)
+            else:
+                return Path(*args, **kwargs)
+
+        aerich.Path = patched_path
+        aerich.migrate.Path = patched_path
+
+        _monkey_patched = True
+
+
+# ----------------------------- /Monkey Patching -----------------------------
+
+
+def get_coloco_app():
+    _verify_app()
+    return get_current_app()
+
+
+def get_model_apps(coloco_app: ColocoApp):
+    return [app for app in coloco_app.orm_config["apps"] if app != "models"]
+
+
+async def get_command(
+    app: str = "models", coloco_app: ColocoApp = None, init: bool = True
+):
+    patch_migration_location(coloco_app.migrations_dir)
+    coloco_app = coloco_app or get_coloco_app()
+    command = Command(
+        tortoise_config=coloco_app.orm_config,
+        app=app,
+        location=coloco_app.migrations_dir,
+    )
+    if init:
+        await command.init()
+        # TODO: propose a better way to do this
+        Tortoise.table_name_generator = app_class_to_table_name
+    return command
+
+
+def get_app_migrations_path(app, migrations_dir: str) -> Path:
+    return Path(os.path.join("src", "app", app, migrations_dir))
+
+
+def ensure_app_migrations_dir(app, migrations_dir: str) -> bool:
+    app_migrations_path = get_app_migrations_path(app, migrations_dir)
+    if not app_migrations_path.exists():
+        app_migrations_path.mkdir(parents=True, exist_ok=True)
+        return False
+    return True
+
+
+async def has_migrations_inited(app: str, coloco_app: ColocoApp) -> bool:
+    try:
+        any_migrations = await Aerich.filter(app=app).first()
+        return bool(any_migrations)
+    except OperationalError as e:
+        return False
+
+
+class InitTortoise(Tortoise):
+    pass
+
+
+async def ensure_migrations_init(coloco_app: ColocoApp, safe=False):
+    """
+    Ensure that we have all initial migrations set up
+    Iterates through apps and creates a blank initial migration.
+    Aerich table is created under the app "models" and has the table initialized.
+    """
+    app = "models"
+
+    await Tortoise.init(
+        config=coloco_app.orm_config, table_name_generator=app_class_to_table_name
+    )
+
+    # Ensure we create aerich first
+    app_list = ["models", *get_model_apps(coloco_app)]
+    for app in app_list:
+        has_migrations = await has_migrations_inited(app, coloco_app)
+        if not has_migrations:
+            all_apps = Tortoise.apps
+            single_app = {app: all_apps[app]} if app == "models" else {app: {}}
+            print(
+                f" |- Initializing migrations for [yellow]{app}...[/yellow]",
+                end="",
+                flush=True,
+            )
+            connection = get_app_connection(coloco_app.orm_config, app)
+
+            Tortoise.apps = single_app
+
+            # Create initial aerich table
+            if app == "models":
+                await generate_schema_for_client(connection, safe)
+
+            Migrate.app = app
+            version = await Migrate.generate_version()
+            await Aerich.create(
+                version=version, app=app, content=get_models_describe(app)
+            )
+
+            Tortoise.apps = all_apps
+
+            print("[green]OK[/green]")
+
+    return has_migrations
+
+
+def db_command(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        run(func(*args, **kwargs))
+        run(Tortoise.close_connections())
+
+    return wrapper
+
+
+# ----------------------------- Commands -----------------------------
+
+
+@app.command()
+@db_command
+async def makemigrations(app: str = None):
+    coloco_app = get_coloco_app()
+    apps = [app] if app else get_model_apps(coloco_app)
+
+    await ensure_migrations_init(coloco_app)
+
+    total = 0
+    print("[yellow]Making migrations for all apps...[/yellow]")
+    for app in apps:
+        print(f" |- [yellow]{app}[/yellow] - ", end="", flush=True)
+        ensure_app_migrations_dir(app, coloco_app.migrations_dir)
+        command = await get_command(app, coloco_app)
+
+        # TODO: ensure no unran migrations exist - they will be overrwitten
+
+        # TODO: submit patch for aerich migration cleanup
+        Migrate.upgrade_operators = []
+        Migrate.downgrade_operators = []
+
+        # TODO: better default name?
+        migrations = await command.migrate(name="update", empty=False)
+
+        if migrations:
+            total += 1
+            print("[green]changes detected[/green]")
+        else:
+            print("[gray]no changes[/gray]")
+
+    if total:
+        print(f"[green]{total}[/green] migration{'s' if total > 1 else ''} created.")
+    else:
+        print("No changes found.")
+
+
+@app.command()
+@db_command
+async def migrate(app: str = None):
+    coloco_app = get_coloco_app()
+    apps = [app] if app else get_model_apps(coloco_app)
+
+    await ensure_migrations_init(coloco_app)
+
+    # TODO: do we need to combine these together for proper handling of foreign key relationships?
+    #       ex: app1.Table1 has a field that references app2.Table2 - does table2 need to be created first?
+    total = 0
+    print("[cyan]Running migrations for all apps...[/cyan]")
+    for app in apps:
+        print(f" |- [cyan]{app}[/cyan] - ", end="", flush=True)
+        ensure_app_migrations_dir(app, coloco_app.migrations_dir)
+        command = await get_command(app, coloco_app)
+        migrations = await command.upgrade(run_in_transaction=True)
+        if migrations:
+            total += 1
+            print("[green]migrated[/green]")
+        else:
+            print("no changes")
+
+    if total:
+        print(f"[green]{total} change{'s' if total > 1 else ''} applied.[/green]")
+    else:
+        print("No changes found.")
+
+
+@app.command()
+@db_command
+async def init(app: str = None):
+    coloco_app = get_coloco_app()
+    has_migrations = await ensure_migrations_init(coloco_app)
+    if not has_migrations:
+        print("[green]Database initialized.[/green]")
+    else:
+        print("[green]Database already initialized.[/green]")
+
+
+@app.command()
+@db_command
+async def revert(version: str, fake: bool = False):
+    # TODO: custom reversion based on app or timestamp?
+    # Reversion
+    raise typer.Abort("Not implemented yet")
+    command = await get_command(app)
+    await command.downgrade(version=version, delete=False, fake=fake)
+
+
+@app.command()
+@db_command
+async def heads():
+    command = await get_command()
+    await command.heads()
+
+
+@app.command()
+@db_command
+async def history():
+    command = await get_command()
+    await command.history()

coloco-0.3.5/src/coloco/db.py

@@ -0,0 +1,80 @@
+from contextlib import asynccontextmanager
+from collections import defaultdict
+from rich import print
+
+
+def app_class_to_table_name(cls):
+    try:
+        app_name = cls.__module__.split(".")[-2]
+    except IndexError:
+        raise ValueError(f"Could not determine app name for model {cls}")
+    return f"{app_name}_{cls.__name__.lower()}"
+
+
+def get_orm_config(database_url: str, model_files: list[str]):
+    model_modules = [
+        model_file.replace("./", "").replace("/", ".").replace(".py", "")
+        for model_file in model_files
+    ]
+    app_to_models = defaultdict(list)
+    for model_module in model_modules:
+        app = model_module.lstrip("src.app.").split(".")[0]
+        app_to_models[app].append(model_module)
+    return {
+        "connections": {"default": database_url},
+        "table_name_generator": app_class_to_table_name,
+        "apps": {
+            **{
+                app: {
+                    "models": [
+                        *models,
+                    ],
+                    "default_connection": "default",
+                }
+                for app, models in app_to_models.items()
+            },
+            **{
+                "models": {
+                    "models": [
+                        "aerich.models",
+                    ],
+                    "default_connection": "default",
+                }
+            },
+        },
+    }
+
+
+async def init_tortoise(app):
+    try:
+        from tortoise import Tortoise
+    except ImportError:
+        print(
+            "[red]Tortoise is not installed.  "
+            "Please install it with `pip install tortoise-orm`.  "
+            "If you intend to use anything other than sqlite, "
+            "you will need to install the appropriate database driver as well "
+            "(e.g. `pip install tortoise-orm[asyncpg]` for postgres).[/red]"
+        )
+        raise
+    await Tortoise.init(
+        config=app.orm_config, table_name_generator=app_class_to_table_name
+    )
+    return Tortoise.close_connections
+
+
+def create_lifecycle_connect_database(app):
+    @asynccontextmanager
+    async def lifecycle_connect_database(api):
+        from .app import get_current_app
+
+        app = get_current_app()
+
+        print("[green]Connecting to database...[/green]")
+        close_connections = await init_tortoise(app)
+        print("[green]Database ready[/green]")
+        yield
+        print("[yellow]Closing database connection...[/yellow]")
+        await close_connections()
+
+    return lifecycle_connect_database

coloco-0.3.5/src/coloco/dependencies.py

@@ -0,0 +1,6 @@
+from fastapi import Depends
+from typing import Annotated
+
+from .app import ColocoApp as ColocoAppType, get_current_app
+
+ColocoApp = Annotated[ColocoAppType, Depends(get_current_app)]

coloco-0.3.4/src/coloco/cli/db.py

@@ -1,100 +0,0 @@
-from aerich import Command
-from .api import _verify_app
-from ..app import ColocoApp, get_current_app
-from asyncio import run
-import functools
-import os
-from rich import print
-from tortoise import Tortoise
-import typer
-
-app = typer.Typer()
-
-def get_app():
-    _verify_app()
-    return get_current_app()
-
-async def get_command(app: ColocoApp = None, init: bool = True):
-    app = app or get_app()
-    command = Command(
-        tortoise_config=app.orm_config,
-        app="models",
-        location=app.migrations_dir,
-    )
-    if init:
-        await command.init()
-    return command
-
-def migrations_dir_exists(migrations_dir: str):
-    migrations_dir = os.path.join(migrations_dir, "models")
-    return os.path.exists(migrations_dir)
-
-def ensure_migrations_dir(migrations_dir: str):
-    if not migrations_dir_exists(migrations_dir):
-        print("[red]Please run `coloco db init` first to initialize the database.[/red]")
-        raise typer.Exit(code=1)
-
-def db_command(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        run(func(*args, **kwargs))
-        run(Tortoise.close_connections())
-    return wrapper
-
-@app.command()
-@db_command
-async def makemigrations():
-    app = get_app()
-    ensure_migrations_dir(app.migrations_dir)
-    command = await get_command(app)
-    migrations = await command.migrate(name="update", empty=False)
-    if migrations:
-        print("[green]Migrations created successfully.[/green]")
-    else:
-        print("[gray]No database changes detected.[/gray]")
-
-@app.command()
-@db_command
-async def migrate():
-    app = get_app()
-    ensure_migrations_dir(app.migrations_dir)
-    command = await get_command(app)
-    migrations = await command.upgrade(run_in_transaction=True)
-    if migrations:
-        print("[green]Database migrated successfully.[/green]")
-    else:
-        print("[gray]No database changes detected.[/gray]")
-
-@app.command()
-@db_command
-async def init():
-    app = get_app()
-    if migrations_dir_exists(app.migrations_dir):
-        print("[red]Migrations directory already exists.  You may want to run `coloco db migrate` instead.[/red]")
-        raise typer.Exit(code=1)
-    command = await get_command(app, init=False)
-    await command.init_db(safe=True)
-    print("[green]Database initialized successfully.[/green]")
-
-@app.command()
-@db_command
-async def revert(version: str, fake: bool = False):
-    app = get_app()
-    ensure_migrations_dir(app.migrations_dir)
-    command = await get_command(app)
-    await command.downgrade(version=version, delete=False, fake=fake)
-
-
-@app.command()
-@db_command
-async def heads():
-    command = await get_command()
-    await command.heads()
-
-@app.command()
-@db_command
-async def history():
-    command = await get_command()
-    await command.history()
-
-

coloco-0.3.4/src/coloco/db.py

@@ -1,39 +0,0 @@
-from contextlib import asynccontextmanager
-from rich import print
-
-def get_orm_config(database_url: str, model_files: list[str]):
-    return {
-        "connections": {
-            "default": database_url
-        },
-        "apps": {
-            "models": {
-                "models": [
-                    *[model_file.replace("./", "").replace("/", ".").replace(".py", "") for model_file in model_files],
-                    "aerich.models",
-                ],
-                "default_connection": "default",
-            },
-        },
-    }
-
-@asynccontextmanager
-async def lifecycle_connect_database(api):
-    from .app import get_current_app
-    app = get_current_app()
-
-    try:
-        from tortoise import Tortoise
-    except ImportError:
-        print("[red]Tortoise is not installed.  "
-              "Please install it with `pip install tortoise-orm`.  "
-              "If you intend to use anything other than sqlite, "
-              "you will need to install the appropriate database driver as well "
-              "(e.g. `pip install tortoise-orm[asyncpg]` for postgres).[/red]")
-        raise
-    print("[green]Connecting to database...[/green]")
-    await Tortoise.init(config=app.orm_config)
-    print("[green]Database ready[/green]")
-    yield
-    print("[yellow]Closing database connection...[/yellow]")
-    await Tortoise.close_connections()