nautica 3.0.0__tar.gz

nautica-3.0.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: nautica
+Version: 3.0.0
+Summary: A service management framework
+Author-email: Xellu <xellu@catboys.cc>
+License: MIT
+Project-URL: Homepage, https://github.com/xellu/nautica-api
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: starlette
+Requires-Dist: uvicorn
+Requires-Dist: python-multipart
+Requires-Dist: colorama
+Requires-Dist: tomlkit
+Requires-Dist: click
+Requires-Dist: psutil
+Requires-Dist: textual
+
+# Nautica V3
+
+Nautica V3 _(also referred to as Nautica API, Nautica3, N3)_ is a modular application framework built around a service registry. It provides you with a structured way to manage components of your applications, such as HTTP or Socket servers, background workers, etc.
+
+> N3 is not just an HTTP framework — the HTTP server is one of many services. It's designed for applications that need to coordinate multiple components at once.
+
+## What's Included
+- **Service Registry** with dependency resolver
+- **Lifecycle hooks** for install, start and shutdown
+- TOML **Config system** with key management
+- **Logger** with file output and memory
+- **Shell** for interacting with services
+- **TUI** for live logs, thread and worker inspection _(optional)_
+- **Plugin system** for extending projects without modifying core code
+- **HTTP API** built on Starlette + Uvicorn
+
+---
+
+I made N3 because I was solving the same problems in my projects, those being: configs, logging, figuring out startup orders, not to mention the validation boilerplate on every route. Because of this I made Nautica V2, which solved many of these issues, and V3 to improve on the idea.
+
+## How HTTP API Compares
+
+### Benchmark Performance
+
+| Library | Requests/Second | Avg Latency | Overall |
+| --- | --- | --- | --- |
+| Nautica3 | `2271` | `4.4ms` | - |
+| FastAPI | `2259` | `4.4ms` | 0.5% slower |
+| Flask | `75` | `132.6ms` | 96% slower |
+
+*Ran with 10 workers, for 10 seconds. Nautica3 matches FastAPI despite running additional middleware, requirement parsing, and logging on every request.*
+
+### Code Complexity
+
+Similarly to SvelteKit, Nautica defines the route names for you. This helps to reduce boilerplate (see Flask and FastAPI examples), improve readability, and helps with naming conventions
+
+#### Nautica3
+```py
+# file: src/http/api/v1/auth.py
+from napi.http import HTTP, Context, Reply
+from somewhere import username, password
+
+@HTTP.POST()
+@HTTP.Require(body = {"username": str, "password": str})
+def login(ctx: Context):
+    if ctx.body["username"] == username and ctx.body["password"] == password:
+        return Reply(ok=True)
+    return Reply(ok=False, error="Invalid credentials"), 401
+```
+
+#### Flask
+```py
+# file: main.py
+from flask import Flask, request
+from flask.blueprints import Blueprint
+import json
+from somewhere import username, password
+
+app = Flask(__name__)
+v1auth = Blueprint("v1auth", __name__, url_prefix="/api/v1/auth")
+
+@v1auth.post("/login")
+def login():
+    data = request.get_json(silent=True) or {}
+    if data.get("username") == username and data.get("password") == password:
+        return json.dumps({"ok": True})
+    return json.dumps({"ok": False, "error": "Invalid credentials"}), 401
+
+app.register_blueprint(v1auth)
+app.run(port=8101)
+```
+
+#### FastAPI
+```py
+# file: main.py
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+from somewhere import username, password
+
+app = FastAPI()
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+@app.post("/api/v1/auth/login")
+def login(body: LoginRequest):
+    if body.username == username and body.password == password:
+        return {"ok": True}
+    raise HTTPException(status_code=401, detail="Invalid credentials")
+
+uvicorn.run(app, port=8101)
+```

nautica-3.0.0/README.md

@@ -0,0 +1,94 @@
+# Nautica V3
+
+Nautica V3 _(also referred to as Nautica API, Nautica3, N3)_ is a modular application framework built around a service registry. It provides you with a structured way to manage components of your applications, such as HTTP or Socket servers, background workers, etc.
+
+> N3 is not just an HTTP framework — the HTTP server is one of many services. It's designed for applications that need to coordinate multiple components at once.
+
+## What's Included
+- **Service Registry** with dependency resolver
+- **Lifecycle hooks** for install, start and shutdown
+- TOML **Config system** with key management
+- **Logger** with file output and memory
+- **Shell** for interacting with services
+- **TUI** for live logs, thread and worker inspection _(optional)_
+- **Plugin system** for extending projects without modifying core code
+- **HTTP API** built on Starlette + Uvicorn
+
+---
+
+I made N3 because I was solving the same problems in my projects, those being: configs, logging, figuring out startup orders, not to mention the validation boilerplate on every route. Because of this I made Nautica V2, which solved many of these issues, and V3 to improve on the idea.
+
+## How HTTP API Compares
+
+### Benchmark Performance
+
+| Library | Requests/Second | Avg Latency | Overall |
+| --- | --- | --- | --- |
+| Nautica3 | `2271` | `4.4ms` | - |
+| FastAPI | `2259` | `4.4ms` | 0.5% slower |
+| Flask | `75` | `132.6ms` | 96% slower |
+
+*Ran with 10 workers, for 10 seconds. Nautica3 matches FastAPI despite running additional middleware, requirement parsing, and logging on every request.*
+
+### Code Complexity
+
+Similarly to SvelteKit, Nautica defines the route names for you. This helps to reduce boilerplate (see Flask and FastAPI examples), improve readability, and helps with naming conventions
+
+#### Nautica3
+```py
+# file: src/http/api/v1/auth.py
+from napi.http import HTTP, Context, Reply
+from somewhere import username, password
+
+@HTTP.POST()
+@HTTP.Require(body = {"username": str, "password": str})
+def login(ctx: Context):
+    if ctx.body["username"] == username and ctx.body["password"] == password:
+        return Reply(ok=True)
+    return Reply(ok=False, error="Invalid credentials"), 401
+```
+
+#### Flask
+```py
+# file: main.py
+from flask import Flask, request
+from flask.blueprints import Blueprint
+import json
+from somewhere import username, password
+
+app = Flask(__name__)
+v1auth = Blueprint("v1auth", __name__, url_prefix="/api/v1/auth")
+
+@v1auth.post("/login")
+def login():
+    data = request.get_json(silent=True) or {}
+    if data.get("username") == username and data.get("password") == password:
+        return json.dumps({"ok": True})
+    return json.dumps({"ok": False, "error": "Invalid credentials"}), 401
+
+app.register_blueprint(v1auth)
+app.run(port=8101)
+```
+
+#### FastAPI
+```py
+# file: main.py
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+from somewhere import username, password
+
+app = FastAPI()
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+@app.post("/api/v1/auth/login")
+def login(body: LoginRequest):
+    if body.username == username and body.password == password:
+        return {"ok": True}
+    raise HTTPException(status_code=401, detail="Invalid credentials")
+
+uvicorn.run(app, port=8101)
+```

nautica-3.0.0/napi/__init__.py

@@ -0,0 +1 @@
+from . import http

nautica-3.0.0/napi/http.py

@@ -0,0 +1,91 @@
+
+from nautica.manager import Logger
+
+from nautica.services.builtins.http.middleware import Middleware
+from nautica.models.Http import RouteRequirements, RequestContext as Context, Reply, ErrorReply as Error
+from nautica.models import Requirements
+from nautica.ext import StatusCodes
+
+from starlette.responses import JSONResponse, PlainTextResponse, FileResponse, HTMLResponse, RedirectResponse, StreamingResponse
+
+Require = Requirements
+
+class RouteManager:
+    def __init__(self):
+        self.temp = []
+        
+    def _create(self, r):
+        self.temp.append(r)
+        Logger.debug(f"Registered route for {r.func.__name__}, {r.method=}, {r.name=}")
+
+    def GET(self, name: str | None = None):
+        return Middleware(self, "get", name).decorator
+    
+    def POST(self, name: str | None = None):
+        return Middleware(self, "post", name).decorator
+    
+    def HEAD(self, name: str | None = None):
+        return Middleware(self, "head", name).decorator
+    
+    def PUT(self, name: str | None = None):
+        return Middleware(self, "put", name).decorator
+    
+    def DELETE(self, name: str | None = None):
+        return Middleware(self, "delete", name).decorator
+    
+    def CONNECT(self, name: str | None = None):
+        return Middleware(self, "connect", name).decorator
+
+    def TRACE(self, name: str | None = None):
+        return Middleware(self, "trace", name).decorator
+    
+    def PATCH(self, name: str | None = None):
+        return Middleware(self, "patch", name).decorator
+
+    def Require(self,
+            body: dict = None,
+            headers: dict = None,
+            cookies: dict = None,
+            query: dict = None,
+            files: dict = None
+        ):
+        for field in [body or {}, headers or {}, cookies or {}, query or {}]:
+            for v in field.values():
+                if not (isinstance(v, type) or isinstance(v, Requirements.Requirement)): raise TypeError(f"Context builder only accepts types and Requirements")
+        
+        for v in (files or {}).values():
+            if not isinstance(v, Requirements.File): raise TypeError(f"File dict only accepts Requirements.File, provided '{type(v).__name__}'")
+        
+        def decorator(func):
+            func._requirements = RouteRequirements(
+                body=body,
+                headers=headers,
+                cookies=cookies,
+                query=query,
+                files = files
+            )
+            return func
+    
+        return decorator
+    
+    def Before(self, fn):
+        def decorator(func):
+            if not hasattr(fn, "_before"):
+                fn._before = []
+            fn._before.append(func)
+            return func
+        return decorator
+
+    def After(self, fn):
+        def decorator(func):
+            if not hasattr(fn, "_after"):
+                fn._after = []
+            fn._after.append(func)
+            return func
+        return decorator
+
+    
+    
+        
+
+HTTP = Router = RouteManager()

nautica-3.0.0/nautica/__init__.py

@@ -0,0 +1,12 @@
+from .ext.Static import RELEASE, EDITION
+from .ext import Util
+
+from .manager import Logger, LogLevel
+from .manager import Config, ConfigBuilder
+
+from .services import Service, Services
+
+from . import (
+    models,
+    ext
+)

nautica-3.0.0/nautica/__main__.py

@@ -0,0 +1,9 @@
+from .cli import cli
+from .cli import (
+    Create,
+    Install,
+    Run
+)
+
+if __name__ == "__main__":
+    cli()

nautica-3.0.0/nautica/cli/Create.py

@@ -0,0 +1,49 @@
+from . import cli, click
+
+import os
+from colorama import Fore
+
+from ..ext.Static import banner, GitIgnore, ProjectExample
+from ..ext.Util import walkPath
+
+from ..manager import Logger, LogLevel
+
+from ..services import Registry
+
+@cli.command()
+@click.argument("name", type=str)
+def create(name):
+    print(f"{Fore.BLUE}{banner()}{Fore.RESET}")
+    if os.path.exists(name) and len(walkPath(name, include_dirs=True)) > 0:
+        Logger.error(f"A Non-empty directory with this name already exists")
+        return
+    
+    #prep working directory
+    Logger.info("Creating project directories...")
+    os.makedirs(name, exist_ok=True)
+    os.chdir(name)
+    
+    for f in [".logs", "config", "plugins", "src/http"]:
+        os.makedirs(f, exist_ok=True)
+
+    with open(".gitignore", "w") as f: f.write(GitIgnore)
+    with open("src/http/+root.py", "w") as f: f.write(ProjectExample)    
+
+    Logger.ok("Created project tree")
+    
+    #install services
+    Logger.info("Installing services...")
+    
+    Registry.ImportAll()
+    Registry.onInstall()
+    
+    Logger.ok("Services Installed")
+    
+    #clean up
+    os.chdir("..")
+    
+    Logger.table() \
+        .labels(["Project Created! Get Started by running:"]) \
+        .row([f"cd {name}"]).row(["nautica install"]).row(["nautica run ."]) \
+        .row([""]).row(["Thank you for using Nautica3!"]) \
+        .display(LogLevel.DEBUG)

nautica-3.0.0/nautica/cli/Install.py

@@ -0,0 +1,35 @@
+from . import cli
+
+import os
+from colorama import Fore
+
+from ..ext.Static import banner
+
+from ..manager import Logger, LogLevel
+from ..manager.config import ROOT_CONFIGS
+
+from ..services import Registry
+
+@cli.command(aliases=["i"])
+def install():
+    print(f"{Fore.BLUE}{banner()}{Fore.RESET}")
+
+    Logger.info("Validating project configuration...")    
+    for path in ROOT_CONFIGS.values():
+        if not os.path.exists(path):
+            Logger.error(f"Project config '{path}' is missing!")
+            return
+    
+    #add download sequence whenever i add package manager
+    
+    #install services
+    Logger.info("Installing services...")
+    
+    Registry.ImportAll()
+    Registry.onInstall()
+    
+    Logger.ok("Services Installed")
+    
+    Logger.table() \
+        .labels(["Services Installed"]) \
+        .display(LogLevel.DEBUG)

nautica-3.0.0/nautica/cli/Run.py

@@ -0,0 +1,25 @@
+from . import cli, click
+
+import os
+from colorama import Fore
+
+from ..ext.Static import banner
+
+from ..manager import Logger, LogLevel
+from ..manager.config import ROOT_CONFIGS
+
+from ..services import Services
+
+@cli.command()
+@click.argument("path", type=str)
+def run(path: str = "."):
+    print(f"{Fore.BLUE}{banner()}{Fore.RESET}")
+
+    Logger.info("Validating project configuration...")    
+    for path in ROOT_CONFIGS.values():
+        if not os.path.exists(path):
+            Logger.error(f"Project config '{path}' is missing!")
+            return
+        
+    Services.ImportAll()
+    Services.onStart()

nautica-3.0.0/nautica/cli/__init__.py

@@ -0,0 +1,17 @@
+import os
+import click
+
+
+class AliasedGroup(click.Group):
+    def command(self, *args, aliases: list[str] = None, **kwargs):
+        decorator = super().command(*args, **kwargs)
+        def wrapper(func):
+            cmd = decorator(func)
+            for alias in (aliases or []):
+                self.add_command(cmd, name=alias)
+            return cmd
+        return wrapper
+
+
+@click.group(cls=AliasedGroup)
+def cli(): ...