ohmyapi 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

ohmyapi/__init__.py

@@ -1 +1 @@
-__VERSION__ = "0.3.2"
+__VERSION__ = "0.4.0"

ohmyapi/builtin/auth/models.py

@@ -1,25 +1,40 @@
+import hmac
+import hashlib
+import base64
 from functools import wraps
+from secrets import token_bytes
 from typing import List, Optional
 from uuid import UUID
 
 from passlib.context import CryptContext
 from tortoise.contrib.pydantic import pydantic_queryset_creator
 
-from ohmyapi.db import Model, field, pre_delete, pre_save
+from ohmyapi.db import Model, field, Q
 from ohmyapi.router import HTTPException
 
+import settings
+
 pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+SECRET_KEY = getattr(settings, "SECRET_KEY", "OhMyAPI Secret Key")
+
+
+def hmac_hash(data: str) -> str:
+    digest = hmac.new(SECRET_KEY.encode("UTF-8"), data.encode("utf-8"), hashlib.sha256).digest()
+    return base64.urlsafe_b64encode(digest).decode("utf-8")
 
 
 class Group(Model):
     id: UUID = field.data.UUIDField(pk=True)
     name: str = field.CharField(max_length=42, index=True)
 
+    def __str__(self):
+        return self.name if self.name else ""
+
 
 class User(Model):
     id: UUID = field.data.UUIDField(pk=True)
-    email: str = field.CharField(max_length=255, unique=True, index=True)
     username: str = field.CharField(max_length=150, unique=True)
+    email_hash: Optional[str] = field.CharField(max_length=255, unique=True, index=True)
     password_hash: str = field.CharField(max_length=128)
     is_admin: bool = field.BooleanField(default=False)
     is_staff: bool = field.BooleanField(default=False)
@@ -28,18 +43,30 @@ class User(Model):
     )
 
     class Schema:
-        exclude = ("password_hash",)
+        exclude = ["password_hash", "email_hash"]
+
+    def __str__(self):
+        fields = {
+            'username': self.username if self.username else "-",
+            'is_admin': 'y' if self.is_admin else 'n',
+            'is_staff': 'y' if self.is_staff else 'n',
+        }
+        return ' '.join([f"{k}:{v}" for k, v in fields.items()])
 
     def set_password(self, raw_password: str) -> None:
         """Hash and store the password."""
         self.password_hash = pwd_context.hash(raw_password)
 
+    def set_email(self, new_email: str) -> None:
+        """Hash and set the e-mail address."""
+        self.email_hash = hmac_hash(email)
+
     def verify_password(self, raw_password: str) -> bool:
         """Verify a plaintext password against the stored hash."""
         return pwd_context.verify(raw_password, self.password_hash)
 
     @classmethod
-    async def authenticate(cls, username: str, password: str) -> Optional["User"]:
+    async def authenticate_username(cls, username: str, password: str) -> Optional["User"]:
         """Authenticate a user by username and password."""
         user = await cls.filter(username=username).first()
         if user and user.verify_password(password):

ohmyapi/cli.py

@@ -9,6 +9,9 @@ import typer
 import uvicorn
 
 from ohmyapi.core import runtime, scaffolding
+from ohmyapi.core.logging import setup_logging
+
+logger = setup_logging()
 
 app = typer.Typer(
     help="OhMyAPI — Django-flavored FastAPI scaffolding with tightly integrated TortoiseORM."
@@ -19,18 +22,24 @@ app = typer.Typer(
 def startproject(name: str):
     """Create a new OhMyAPI project in the given directory."""
     scaffolding.startproject(name)
+    logger.info(f"✅ Project '{name}' created successfully.")
+    logger.info(f"🔧 Next, configure your project in {name}/settings.py")
 
 
 @app.command()
 def startapp(app_name: str, root: str = "."):
     """Create a new app with the given name in your OhMyAPI project."""
     scaffolding.startapp(app_name, root)
+    print(f"✅ App '{app_name}' created in project '{root}' successfully.")
+    print(f"🔧 Remember to add '{app_name}' to your INSTALLED_APPS!")
 
 
 @app.command()
 def dockerize(root: str = "."):
     """Create template Dockerfile and docker-compose.yml."""
     scaffolding.copy_static("docker", root)
+    logger.info(f"✅ Templates created successfully.")
+    logger.info(f"🔧 Next, run `docker compose up -d --build`")
 
 
 @app.command()
@@ -40,9 +49,8 @@ def serve(root: str = ".", host="127.0.0.1", port=8000):
     """
     project_path = Path(root)
     project = runtime.Project(project_path)
-    app_instance = project.app()
-    app_instance = project.configure_app(app_instance)
-    uvicorn.run(app_instance, host=host, port=int(port), reload=False)
+    app_instance = project.configure_app(project.app())
+    uvicorn.run(app_instance, host=host, port=int(port), reload=False, log_config=None)
 
 
 @app.command()
@@ -75,7 +83,7 @@ def shell(root: str = "."):
     asyncio.set_event_loop(loop)
     loop.run_until_complete(init_and_cleanup())
 
-    # Prepare shell vars that are to be directly available
+    # Prepare shell vars that are to be immediately available
     shell_vars = {"p": project}
 
     try:
@@ -107,6 +115,8 @@ def makemigrations(app: str = "*", name: str = "auto", root: str = "."):
             asyncio.run(project.makemigrations(app_label=app, name=name))
     else:
         asyncio.run(project.makemigrations(app_label=app, name=name))
+    logger.info(f"✅ Migrations created successfully.")
+    logger.info(f"🔧 To migrate the DB, run `ohmyapi migrate`, next.")
 
 
 @app.command()
@@ -121,6 +131,7 @@ def migrate(app: str = "*", root: str = "."):
             asyncio.run(project.migrate(app))
     else:
         asyncio.run(project.migrate(app))
+    logger.info(f"✅ Migrations ran successfully.")
 
 
 @app.command()
@@ -150,8 +161,9 @@ def createsuperuser(root: str = "."):
         if password1 != password2:
             print("Passwords didn't match!")
     user = ohmyapi_auth.models.User(
-        email=email, username=username, is_staff=True, is_admin=True
+        username=username, is_staff=True, is_admin=True
     )
+    user.set_email(email)
     user.set_password(password1)
     asyncio.run(project.init_orm())
     asyncio.run(user.save())

ohmyapi/core/logging.py

@@ -0,0 +1,38 @@
+import logging
+import os
+import sys
+
+
+def setup_logging():
+    """Configure unified logging for ohmyapi + FastAPI/Uvicorn."""
+    log_level = os.getenv("OHMYAPI_LOG_LEVEL", "INFO").upper()
+    level = getattr(logging, log_level, logging.INFO)
+
+    # Root logger (affects FastAPI, uvicorn, etc.)
+    logging.basicConfig(
+        level=level,
+        format="[%(asctime)s] [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        handlers=[
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+
+    # Separate ohmyapi logger (optional)
+    logger = logging.getLogger("ohmyapi")
+
+    # Direct warnings/errors to stderr
+    class LevelFilter(logging.Filter):
+        def filter(self, record):
+            # Send warnings+ to stderr, everything else to stdout
+            if record.levelno >= logging.WARNING:
+                record.stream = sys.stderr
+            else:
+                record.stream = sys.stdout
+            return True
+
+    for handler in logger.handlers:
+        handler.addFilter(LevelFilter())
+
+    logger.setLevel(level)
+    return logger

ohmyapi/core/runtime.py

@@ -7,7 +7,7 @@ import sys
 from http import HTTPStatus
 from pathlib import Path
 from types import ModuleType
-from typing import Any, Dict, Generator, List, Optional, Type
+from typing import Any, Dict, Generator, List, Optional, Tuple, Type
 
 import click
 from aerich import Command as AerichCommand
@@ -15,8 +15,11 @@ from aerich.exceptions import NotInitedError
 from fastapi import APIRouter, FastAPI
 from tortoise import Tortoise
 
+from ohmyapi.core.logging import setup_logging
 from ohmyapi.db.model import Model
 
+logger = setup_logging()
+
 
 class Project:
     """
@@ -29,6 +32,7 @@ class Project:
     """
 
     def __init__(self, project_path: str):
+        logger.debug(f"Loading project: {project_path}")
         self.project_path = Path(project_path).resolve()
         self._apps: Dict[str, App] = {}
         self.migrations_dir = self.project_path / "migrations"
@@ -88,10 +92,14 @@ class Project:
 
     def configure_app(self, app: FastAPI) -> FastAPI:
         """
-        Attach project routes and event handlers to given FastAPI instance.
+        Attach project middlewares and routes and event handlers to given
+        FastAPI instance.
         """
-        # Attach project routes.
+        app.router.prefix = getattr(self.settings, "API_PREFIX", "")
+        # Attach project middlewares and routes.
         for app_name, app_def in self._apps.items():
+            for middleware, kwargs in app_def.middlewares:
+                app.add_middleware(middleware, **kwargs)
             for router in app_def.routers:
                 app.include_router(router)
 
@@ -229,11 +237,16 @@ class App:
         # Reference to this app's routes modules.
         self._routers: Dict[str, ModuleType] = {}
 
+        # Reference to this apps middlewares.
+        self._middlewares: List[Tuple[Any, Dict[str, Any]]] = []
+
         # Import the app, so its __init__.py runs.
         mod: ModuleType = importlib.import_module(name)
 
+        logger.debug(f"Loading app: {self.name}")
         self.__load_models(f"{self.name}.models")
         self.__load_routes(f"{self.name}.routes")
+        self.__load_middlewares(f"{self.name}.middlewares")
 
     def __repr__(self):
         return json.dumps(self.dict(), indent=2)
@@ -251,7 +264,6 @@ class App:
         try:
             importlib.import_module(mod_name)
         except ModuleNotFoundError:
-            print(f"no models detected: {mod_name}")
             return
 
         # Acoid duplicates.
@@ -269,9 +281,11 @@ class App:
                     and issubclass(value, Model)
                     and not name == Model.__name__
                 ):
+                    # monkey-patch __module__ to point to well-known aliases
                     value.__module__ = value.__module__.replace("ohmyapi.builtin.", "ohmyapi_")
                     if value.__module__.startswith(mod_name):
                         self._models[mod_name] = self._models.get(mod_name, []) + [value]
+                        logger.debug(f" - Model: {mod_name} -> {name}")
 
             # if it's a package, recurse into submodules
             if hasattr(mod, "__path__"):
@@ -293,7 +307,6 @@ class App:
         try:
             importlib.import_module(mod_name)
         except ModuleNotFound:
-            print(f"no routes detected: {mod_name}")
             return
 
         # Avoid duplicates.
@@ -308,6 +321,7 @@ class App:
             for name, value in vars(mod).copy().items():
                 if isinstance(value, APIRouter) and not name == APIRouter.__name__:
                     self._routers[mod_name] = self._routers.get(mod_name, []) + [value]
+                    logger.debug(f" - Router: {mod_name} -> {name} -> {value.routes}")
 
             # if it's a package, recurse into submodules
             if hasattr(mod, "__path__"):
@@ -319,6 +333,17 @@ class App:
         # Walk the walk.
         walk(mod_name)
 
+    def __load_middlewares(self, mod_name):
+        try:
+            mod = importlib.import_module(mod_name)
+        except ModuleNotFoundError:
+            return
+
+        getter = getattr(mod, "get", None)
+        if getter is not None:
+            for middleware in getter():
+                self._middlewares.append(middleware)
+
     def __serialize_route(self, route):
         """
         Convert APIRoute to JSON-serializable dict.
@@ -332,6 +357,12 @@ class App:
     def __serialize_router(self):
         return [self.__serialize_route(route) for route in self.routes]
 
+    def __serialize_middleware(self):
+        out = []
+        for m in self.middlewares:
+            out.append((m[0].__name__, m[1]))
+        return out
+
     @property
     def models(self) -> List[ModuleType]:
         """
@@ -363,6 +394,11 @@ class App:
             out.extend(r.routes)
         return out
 
+    @property
+    def middlewares(self):
+        """Returns the list of this app's middlewares."""
+        return self._middlewares
+
     def dict(self) -> Dict[str, Any]:
         """
         Convenience method for serializing the runtime data.
@@ -371,5 +407,6 @@ class App:
             "models": [
                 f"{self.name}.{m.__name__}" for m in self.models[f"{self.name}.models"]
             ],
+            "middlewares": self.__serialize_middleware(),
             "routes": self.__serialize_router(),
         }

ohmyapi/core/scaffolding.py

@@ -2,12 +2,16 @@ from pathlib import Path
 
 from jinja2 import Environment, FileSystemLoader
 
+from ohmyapi.core.logging import setup_logging
+
 import shutil
 
 # Base templates directory
 TEMPLATE_DIR = Path(__file__).parent / "templates"
 env = Environment(loader=FileSystemLoader(str(TEMPLATE_DIR)))
 
+logger = setup_logging()
+
 
 def render_template_file(template_path: Path, context: dict, output_path: Path):
     """Render a single Jinja2 template file to disk."""
@@ -60,7 +64,7 @@ def copy_static(dir_name: str, target_dir: Path):
     template_dir = TEMPLATE_DIR / dir_name
     target_dir = Path(target_dir)
     if not template_dir.exists():
-        print(f"no templates found under: {dir_name}")
+        logger.error(f"no templates found under: {dir_name}")
         return
 
     for root, _, files in template_dir.walk():
@@ -69,19 +73,15 @@ def copy_static(dir_name: str, target_dir: Path):
             src = root_path / file
             dst = target_dir / file
             if dst.exists():
-                print(f"⛔ File exists, skipping: {dst}")
+                logger.warning(f"⛔ File exists, skipping: {dst}")
                 continue
-            shutil.copy(src, ".")
-    print(f"✅ Templates created successfully.")
-    print(f"🔧 Next, run `docker compose up -d --build`")
+            shutil.copy(src, dst)
 
 def startproject(name: str):
     """Create a new project: flat structure, all project templates go into <name>/"""
     target_dir = Path(name).resolve()
     target_dir.mkdir(exist_ok=True)
     render_template_dir("project", target_dir, {"project_name": name})
-    print(f"✅ Project '{name}' created successfully.")
-    print(f"🔧 Next, configure your project in {target_dir / 'settings.py'}")
 
 
 def startapp(name: str, project: str):
@@ -94,5 +94,3 @@ def startapp(name: str, project: str):
         {"project_name": target_dir.resolve().name, "app_name": name},
         subdir_name=name,
     )
-    print(f"✅ App '{name}' created in project '{target_dir}' successfully.")
-    print(f"🔧 Remember to add '{name}' to your INSTALLED_APPS!")

ohmyapi/core/templates/docker/Dockerfile

@@ -21,7 +21,6 @@ ENV PATH="$POETRY_HOME/bin:$PATH"
 
 WORKDIR /app
 COPY pyproject.toml poetry.lock* /app/
-RUN poetry lock
 RUN poetry install
 COPY . /app
 

ohmyapi/core/templates/docker/docker-compose.yml

@@ -1,4 +1,14 @@
 services:
+  # db:
+  #   image: postgres:latest
+  #   restart: unless-stopped
+  #   environment:
+  #     POSTGRES_DB: ohmyapi
+  #     POSTGRES_USER: ohmyapi
+  #     POSTGRES_PASSWORD: ohmyapi
+  #   ports:
+  #     - 5432:5432
+
   app:
     build:
       context: .

ohmyapi/core/templates/project/pyproject.toml.j2

@@ -10,7 +10,7 @@ readme = "README.md"
 license = { text = "MIT" }
 
 dependencies = [
-    "ohmyapi"
+#    "asyncpg"
 ]
 
 [tool.poetry.group.dev.dependencies]

ohmyapi/db/__init__.py

@@ -1,3 +1,4 @@
+from tortoise.expressions import Q
 from tortoise.manager import Manager
 from tortoise.queryset import QuerySet
 from tortoise.signals import (

ohmyapi/middleware/cors.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from typing import Any, Dict, List, Tuple
+
+import settings
+
+DEFAULT_ORIGINS = ["http://localhost", "http://localhost:8000"]
+DEFAULT_CREDENTIALS = False
+DEFAULT_METHODS = ["*"]
+DEFAULT_HEADERS = ["*"]
+
+CORS_CONFIG: Dict[str, Any] = getattr(settings, "MIDDLEWARE_CORS", {})
+
+if not isinstance(CORS_CONFIG, dict):
+    raise ValueError("MIDDLEWARE_CORS must be of type dict")
+
+middleware = [
+    (CORSMiddleware, {
+        "allow_origins": CORS_CONFIG.get("ALLOW_ORIGINS", DEFAULT_ORIGINS),
+        "allow_credentials": CORS_CONFIG.get("ALLOW_CREDENTIALS", DEFAULT_CREDENTIALS),
+        "allow_methods": CORS_CONFIG.get("ALLOW_METHODS", DEFAULT_METHODS),
+        "allow_headers": CORS_CONFIG.get("ALLOW_HEADERS", DEFAULT_HEADERS),
+    }),
+]
+

{ohmyapi-0.3.2.dist-info → ohmyapi-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ohmyapi
-Version: 0.3.2
+Version: 0.4.0
 Summary: Django-flavored scaffolding and management layer around FastAPI, Pydantic, TortoiseORM and Aerich migrations
 License-Expression: MIT
 Keywords: fastapi,tortoise,orm,pydantic,async,web-framework
@@ -35,9 +35,10 @@ Description-Content-Type: text/markdown
 
 # OhMyAPI
 
-OhMyAPI is a web-application scaffolding framework and management layer built around `FastAPI`, `TortoiseORM` and `Aerich` migrations.
+OhMyAPI is a web-application scaffolding framework and management layer built around `FastAPI`.
+It is a thin layer that tightly integrates TortoiseORM and Aerich migrations.
 
-> *Think: Django RestFramework, but less clunky and 100% async.*
+> *Think: *"Django RestFramework"*, but less clunky and instead 100% async.*
 
 It is ***blazingly fast***, extremely ***fun to use*** and comes with ***batteries included***!
 
@@ -47,7 +48,7 @@ It is ***blazingly fast***, extremely ***fun to use*** and comes with ***batteri
 - Django-like per-app migrations (makemigrations & migrate) via Aerich
 - Django-like CLI tooling (startproject, startapp, shell, serve, etc)
 - Customizable pydantic model serializer built-in
-- Various optional built-in apps you can hook into your project
+- Various optional built-in apps you can hook into your project (i.e. authentication and more)
 - Highly configurable and customizable
 - 100% async
 

{ohmyapi-0.3.2.dist-info → ohmyapi-0.4.0.dist-info}/RECORD

@@ -1,30 +1,32 @@
-ohmyapi/__init__.py,sha256=2oHRA-Di_T9uJrAqGarogp-SaY0SBCIWtlLOxTyTviE,22
+ohmyapi/__init__.py,sha256=2ohBfKaesG66_1MkCKfwltW-m1FPoCxzeDJDsA74KDc,22
 ohmyapi/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
 ohmyapi/builtin/auth/__init__.py,sha256=vOVCSJX8BALzs8h5ZW9507bjoscP37bncMjdMmBXcMM,42
-ohmyapi/builtin/auth/models.py,sha256=8az4TKdC6PUha3_HyslKinDT2-yAN-aBoYUQcjxm7Js,1728
+ohmyapi/builtin/auth/models.py,sha256=3T6q0K3S9U__zif784oSb44bWqt3oCTpgPJlEK1YPFk,2598
 ohmyapi/builtin/auth/permissions.py,sha256=mxsnhF_UGesTFle7v1JHORkNODtQ0qanAL3FtOcMCEY,145
 ohmyapi/builtin/auth/routes.py,sha256=r887BWea20vinX88QBuxGzQc9BrIi-LqyStM0V1cl1o,6304
 ohmyapi/builtin/demo/__init__.py,sha256=44Yo3mYmlKSKEwVp6O9urr-C_3qDQzCYLMn6B9i6wew,29
 ohmyapi/builtin/demo/models.py,sha256=r06rfuhPJaI2fYsQ24L1JCOd67f2GQNfGnkgKAptOX8,1404
 ohmyapi/builtin/demo/routes.py,sha256=1VTlEttrez6Qnhrz_9sTA-emtfXem0s0BkPVcLvg3k0,1801
-ohmyapi/cli.py,sha256=gHiPWN3pkrrIJ69WFBHt0BTRNVI-YSJD7VhtqQRwKuc,4447
+ohmyapi/cli.py,sha256=iWP0vPkodC_Y3MenNs9AH8FR_d-XpoXliGtz4inWkR4,5114
 ohmyapi/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ohmyapi/core/runtime.py,sha256=pNfFRk7sFX8FePX6cnb4H7kLh5CauNnA_gmc0rsWIh8,12287
-ohmyapi/core/scaffolding.py,sha256=1KF67aBvd08xjDhIXhI-nDhClJAw2TB3tYVLiMmeYOk,3426
+ohmyapi/core/logging.py,sha256=YHN-I2--WP1uXy4W3Q1aD1XLiG9-CrVWvyCYe8HsD9E,1094
+ohmyapi/core/runtime.py,sha256=NxTMMo4mHJlUxhDZWTxzYvTWkQKEuTrgVuZ-g6mHabg,13681
+ohmyapi/core/scaffolding.py,sha256=EehJesfDBB8vcMvc_T351QYdyJuyMGBA__BpLT33oVA,3122
 ohmyapi/core/templates/app/__init__.py.j2,sha256=QwVIQVUGZVhdH1d4NrvL7NTsK4-T4cihzYs8UVX2dt4,43
 ohmyapi/core/templates/app/models.py.j2,sha256=_3w-vFJ5fgsmncsCv34k_wyCMF78jufbSSglns4gbb0,119
 ohmyapi/core/templates/app/routes.py.j2,sha256=SxLz_wvakusj5txbXToZyNq6ZmcamSwNjVrI0MNPRl0,1037
-ohmyapi/core/templates/docker/Dockerfile,sha256=4-QgqK6h9sR7hYKGUvRife6GpLTm7EOzYupr54B3qUY,596
-ohmyapi/core/templates/docker/docker-compose.yml,sha256=Jr344DALp28_w9d9O-HIuQgwaacIHabyFyvBuOQ-PeQ,102
+ohmyapi/core/templates/docker/Dockerfile,sha256=KnfCscQYf1VQHrn_LVs1sNlcbsslHoRKbgMeGjuwD7k,580
+ohmyapi/core/templates/docker/docker-compose.yml,sha256=GnFZN8hrxrIdpqQ2COMmBoFcfeiUiWtI4fm58KvjQOY,317
 ohmyapi/core/templates/project/README.md.j2,sha256=SjR4JIrg-8XRE-UntUDwiw8jDpYitD_UjwoKkYJ7GLw,22
-ohmyapi/core/templates/project/pyproject.toml.j2,sha256=D3d5yv2317owH3tFYN6klMavt74gTqqhDsHe0jhqUeA,521
+ohmyapi/core/templates/project/pyproject.toml.j2,sha256=xXMlZOZ4ewyE7Xlvk8kwyF1781-AZfG_CuNtXQGfxqk,522
 ohmyapi/core/templates/project/settings.py.j2,sha256=So6w1OiL_jU-FyeT8IHueDjGNuEoSkYhabhHpne2fUU,140
-ohmyapi/db/__init__.py,sha256=5QKUycxnN83DOUD_Etoee9tEOYjnZ74deqrSOOx_MiQ,204
+ohmyapi/db/__init__.py,sha256=qoZZvji8wLwU38DSw9IcQOZm0C2sMF-fGn-b1J1fzws,239
 ohmyapi/db/exceptions.py,sha256=vb4IIUoeYAY6sK42zRtjMy-39IFVi_Qb6mWySTY0jYw,34
 ohmyapi/db/model/__init__.py,sha256=k3StTNuKatpwZo_Z5JBFa-927eJrzibFE8U4SA82asc,32
 ohmyapi/db/model/model.py,sha256=ui4g78c5xoS06Dj8Cdk7QgTjRnE68zKeL-AdmeYYPuQ,2776
+ohmyapi/middleware/cors.py,sha256=p8HlKsZLM6jKLEa2-q22cIEZUKawirMQB9ajfxaM4xw,818
 ohmyapi/router.py,sha256=5g0U59glu4hxxnIoTSFzb2S2offkOT3eE39aprzVxwo,83
-ohmyapi-0.3.2.dist-info/METADATA,sha256=jN-z3UGK2i-h4f4jbRr_buU8FfPkTKxKr3W9fSrxQ0E,2575
-ohmyapi-0.3.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-ohmyapi-0.3.2.dist-info/entry_points.txt,sha256=wb3lw8-meAlpiv1mqcQ3m25ukL7djagU_w89GkrC37k,43
-ohmyapi-0.3.2.dist-info/RECORD,,
+ohmyapi-0.4.0.dist-info/METADATA,sha256=xwYfCORH7xurtw3IfqpXQEdLP9hLw1MKrHQ4wdkH3SY,2657
+ohmyapi-0.4.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+ohmyapi-0.4.0.dist-info/entry_points.txt,sha256=wb3lw8-meAlpiv1mqcQ3m25ukL7djagU_w89GkrC37k,43
+ohmyapi-0.4.0.dist-info/RECORD,,