wsbuilder 0.2.7__tar.gz → 0.3.0__tar.gz

{wsbuilder-0.2.7/src/wsbuilder.egg-info → wsbuilder-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wsbuilder
-Version: 0.2.7
+Version: 0.3.0
 Summary: Framework ligero HTTP + WebSocket.
 Author: wsbuilder Authors
 License-Expression: MIT
@@ -25,6 +25,7 @@ Lightweight Python HTTP + WebSocket framework for building real-time APIs and cu
 ## Incluye
 
 - `wsbuilder.framework`: router, request/response, servidor HTTP, handshake WS y utilidades de frames.
+- `wsbuilder.orm`: ORM flexible para SQLite3 (modelos, QuerySet, filtros, transacciones anidadas).
 - `wsbuilder.ws_demo`: demo completo HTTP + WebSocket + REST + SQLite.
 
 ## Instalacion local
@@ -73,6 +74,53 @@ Para CORS sin variables de entorno:
 app = App(cors_allow_origin="*")
 ```
 
+## ORM SQLite3 rapido
+
+```python
+from wsbuilder import Database, IntegerField, Model, TextField
+
+class User(Model):
+    id = IntegerField(primary_key=True, auto_increment=True)
+    username = TextField(unique=True, index=True, null=False)
+    email = TextField(null=False)
+
+db = Database("app.db")
+User.create_table(db)
+
+u = User(username="alice", email="alice@example.com")
+u.save(db)
+
+admins = User.objects(db).filter(username__contains="ali").order_by("-id").all()
+print([x.to_dict() for x in admins])
+```
+
+## Metrics (JSON stream)
+
+```python
+from wsbuilder import App
+
+app = App()
+app.enable_metrics()  # crea /api/metrics y /api/metrics/stream
+```
+
+Probar snapshot:
+
+```bash
+curl http://127.0.0.1:8765/api/metrics
+```
+
+Probar stream NDJSON:
+
+```bash
+curl -N "http://127.0.0.1:8765/api/metrics/stream?interval=1&limit=5"
+```
+
+Modo continuo (no termina solo):
+
+```bash
+curl -N "http://127.0.0.1:8765/api/metrics/stream?interval=1&follow=1"
+```
+
 ## HTTP streaming (chunked)
 
 ```python

{wsbuilder-0.2.7 → wsbuilder-0.3.0}/README.md

@@ -9,6 +9,7 @@ Lightweight Python HTTP + WebSocket framework for building real-time APIs and cu
 ## Incluye
 
 - `wsbuilder.framework`: router, request/response, servidor HTTP, handshake WS y utilidades de frames.
+- `wsbuilder.orm`: ORM flexible para SQLite3 (modelos, QuerySet, filtros, transacciones anidadas).
 - `wsbuilder.ws_demo`: demo completo HTTP + WebSocket + REST + SQLite.
 
 ## Instalacion local
@@ -57,6 +58,53 @@ Para CORS sin variables de entorno:
 app = App(cors_allow_origin="*")
 ```
 
+## ORM SQLite3 rapido
+
+```python
+from wsbuilder import Database, IntegerField, Model, TextField
+
+class User(Model):
+    id = IntegerField(primary_key=True, auto_increment=True)
+    username = TextField(unique=True, index=True, null=False)
+    email = TextField(null=False)
+
+db = Database("app.db")
+User.create_table(db)
+
+u = User(username="alice", email="alice@example.com")
+u.save(db)
+
+admins = User.objects(db).filter(username__contains="ali").order_by("-id").all()
+print([x.to_dict() for x in admins])
+```
+
+## Metrics (JSON stream)
+
+```python
+from wsbuilder import App
+
+app = App()
+app.enable_metrics()  # crea /api/metrics y /api/metrics/stream
+```
+
+Probar snapshot:
+
+```bash
+curl http://127.0.0.1:8765/api/metrics
+```
+
+Probar stream NDJSON:
+
+```bash
+curl -N "http://127.0.0.1:8765/api/metrics/stream?interval=1&limit=5"
+```
+
+Modo continuo (no termina solo):
+
+```bash
+curl -N "http://127.0.0.1:8765/api/metrics/stream?interval=1&follow=1"
+```
+
 ## HTTP streaming (chunked)
 
 ```python

{wsbuilder-0.2.7 → wsbuilder-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wsbuilder"
-version = "0.2.7"
+version = "0.3.0"
 description = "Framework ligero HTTP + WebSocket."
 readme = "README.md"
 requires-python = ">=3.11"

wsbuilder-0.3.0/src/wsbuilder/__init__.py

@@ -0,0 +1,65 @@
+"""wsbuilder: mini framework HTTP + WebSocket."""
+
+from .framework import (
+    App,
+    HTTPServer,
+    Request,
+    Response,
+    Route,
+    Router,
+    WebSocket,
+    parse_close_payload,
+    parse_query_string,
+)
+from .metrics import AppMetrics, install_metrics
+from .orm import (
+    BlobField,
+    BooleanField,
+    Database,
+    DateTimeField,
+    Field,
+    IntegerField,
+    JSONField,
+    Model,
+    QuerySet,
+    RealField,
+    SQL,
+    TextField,
+    Transaction,
+    create_tables,
+    drop_tables,
+    quote_identifier,
+    validate_identifier,
+)
+
+__version__ = "0.3.0"
+__all__ = [
+    "App",
+    "HTTPServer",
+    "Request",
+    "Response",
+    "Route",
+    "Router",
+    "WebSocket",
+    "AppMetrics",
+    "install_metrics",
+    "Database",
+    "Model",
+    "QuerySet",
+    "Transaction",
+    "Field",
+    "IntegerField",
+    "TextField",
+    "RealField",
+    "BlobField",
+    "BooleanField",
+    "DateTimeField",
+    "JSONField",
+    "SQL",
+    "create_tables",
+    "drop_tables",
+    "quote_identifier",
+    "validate_identifier",
+    "parse_close_payload",
+    "parse_query_string",
+]

{wsbuilder-0.2.7 → wsbuilder-0.3.0}/src/wsbuilder/app.py

@@ -32,6 +32,7 @@ class App:
         self.ws_routes = {}
         self.startup_hooks = []
         self.cors_allow_origin = (cors_allow_origin or "").strip()
+        self.metrics = None
 
     def route(self, path, methods=("GET",), kind="plain"):
         def decorator(func):
@@ -56,6 +57,21 @@ class App:
     def add_startup(self, func):
         self.startup_hooks.append(func)
 
+    def enable_metrics(
+        self,
+        path="/api/metrics",
+        stream_path="/api/metrics/stream",
+        app_name=None,
+    ):
+        from .metrics import install_metrics
+
+        return install_metrics(
+            self,
+            path=path,
+            stream_path=stream_path,
+            app_name=app_name,
+        )
+
     def dispatch(self, request):
         cors_allow_origin = self.cors_allow_origin
         if request.method == "OPTIONS":

{wsbuilder-0.2.7 → wsbuilder-0.3.0}/src/wsbuilder/framework.py

@@ -3,6 +3,7 @@
 from .app import App, Route, Router
 from .constants import DEFAULT_CORS_ALLOW_ORIGIN, MAGIC_WS, STATUS_MESSAGES
 from .http import Request, Response, parse_http_request, parse_query_string, send_http_response
+from .metrics import AppMetrics, install_metrics
 from .server import HTTPServer
 from .ws import (
     B64_ALPHABET,
@@ -22,6 +23,8 @@ __all__ = [
     "HTTPServer",
     "Request",
     "Response",
+    "AppMetrics",
+    "install_metrics",
     "Route",
     "Router",
     "WebSocket",
@@ -41,4 +44,3 @@ __all__ = [
     "send_http_response",
     "sha1",
 ]
-

wsbuilder-0.3.0/src/wsbuilder/metrics.py

@@ -0,0 +1,264 @@
+"""Application metrics collector and JSON streaming helpers."""
+
+import json
+import threading
+import time
+from datetime import UTC, datetime
+
+from .http import Response
+
+DEFAULT_STREAM_POINTS = 5
+
+
+def _iso_utc(ts):
+    return datetime.fromtimestamp(ts, UTC).isoformat()
+
+
+def _safe_int(value, default):
+    try:
+        return int(value)
+    except Exception:
+        return default
+
+
+def _safe_float(value, default):
+    try:
+        return float(value)
+    except Exception:
+        return default
+
+
+def _is_truthy(value):
+    if value is None:
+        return False
+    text = str(value).strip().lower()
+    return text in {"1", "true", "yes", "on"}
+
+
+class AppMetrics:
+    def __init__(self, app_name="wsbuilder-app"):
+        self.app_name = app_name
+        self.started_at = time.time()
+        self._lock = threading.Lock()
+
+        self.active_tcp_connections = 0
+        self.total_tcp_connections = 0
+
+        self.active_http_requests = 0
+        self.total_http_requests = 0
+        self.total_http_responses = 0
+        self.http_methods = {}
+        self.http_paths = {}
+        self.http_status = {}
+        self.http_total_duration_ms = 0.0
+        self.http_max_duration_ms = 0.0
+
+        self.active_ws_connections = 0
+        self.total_ws_upgrades = 0
+        self.ws_paths = {}
+        self.ws_messages_in = 0
+        self.ws_messages_out = 0
+        self.ws_bytes_in = 0
+        self.ws_bytes_out = 0
+
+        self.bytes_in = 0
+        self.bytes_out = 0
+
+        self.total_errors = 0
+        self.last_error = ""
+
+    def _inc_map(self, data, key, step=1):
+        data[key] = data.get(key, 0) + step
+
+    def tcp_connection_open(self):
+        with self._lock:
+            self.active_tcp_connections += 1
+            self.total_tcp_connections += 1
+
+    def tcp_connection_close(self):
+        with self._lock:
+            if self.active_tcp_connections > 0:
+                self.active_tcp_connections -= 1
+
+    def http_request_started(self, method, path, body_size=0):
+        method = (method or "").upper() or "UNKNOWN"
+        path = path or "/"
+        body_size = max(0, int(body_size or 0))
+        with self._lock:
+            self.active_http_requests += 1
+            self.total_http_requests += 1
+            self.bytes_in += body_size
+            self._inc_map(self.http_methods, method)
+            self._inc_map(self.http_paths, path)
+
+    def http_response_sent(self, method, path, status, body_size=0, duration_ms=0.0):
+        status_key = str(int(status or 0))
+        body_size = max(0, int(body_size or 0))
+        duration_ms = max(0.0, float(duration_ms or 0.0))
+        with self._lock:
+            if self.active_http_requests > 0:
+                self.active_http_requests -= 1
+            self.total_http_responses += 1
+            self.bytes_out += body_size
+            self._inc_map(self.http_status, status_key)
+            self.http_total_duration_ms += duration_ms
+            if duration_ms > self.http_max_duration_ms:
+                self.http_max_duration_ms = duration_ms
+
+    def ws_opened(self, path):
+        path = path or "/ws/"
+        with self._lock:
+            self.active_ws_connections += 1
+            self.total_ws_upgrades += 1
+            self._inc_map(self.ws_paths, path)
+
+    def ws_closed(self, path):
+        with self._lock:
+            if self.active_ws_connections > 0:
+                self.active_ws_connections -= 1
+
+    def ws_message_in(self, payload_size=0):
+        payload_size = max(0, int(payload_size or 0))
+        with self._lock:
+            self.ws_messages_in += 1
+            self.ws_bytes_in += payload_size
+            self.bytes_in += payload_size
+
+    def ws_message_out(self, payload_size=0):
+        payload_size = max(0, int(payload_size or 0))
+        with self._lock:
+            self.ws_messages_out += 1
+            self.ws_bytes_out += payload_size
+            self.bytes_out += payload_size
+
+    def error(self, where, exc):
+        msg = f"{where}: {exc}"
+        with self._lock:
+            self.total_errors += 1
+            self.last_error = msg
+
+    def snapshot(self):
+        now = time.time()
+        with self._lock:
+            methods = dict(self.http_methods)
+            paths = dict(self.http_paths)
+            status = dict(self.http_status)
+            ws_paths = dict(self.ws_paths)
+            total_responses = self.total_http_responses
+            avg_ms = 0.0
+            if total_responses > 0:
+                avg_ms = self.http_total_duration_ms / float(total_responses)
+
+            data = {
+                "app_name": self.app_name,
+                "timestamp_unix": now,
+                "timestamp_utc": _iso_utc(now),
+                "started_at_unix": self.started_at,
+                "started_at_utc": _iso_utc(self.started_at),
+                "uptime_seconds": round(now - self.started_at, 3),
+                "connections": {
+                    "tcp_active": self.active_tcp_connections,
+                    "tcp_total": self.total_tcp_connections,
+                    "http_inflight": self.active_http_requests,
+                    "ws_active": self.active_ws_connections,
+                },
+                "http": {
+                    "requests_total": self.total_http_requests,
+                    "responses_total": self.total_http_responses,
+                    "methods": methods,
+                    "paths": paths,
+                    "status": status,
+                    "duration_ms_avg": round(avg_ms, 3),
+                    "duration_ms_max": round(self.http_max_duration_ms, 3),
+                },
+                "websocket": {
+                    "upgrades_total": self.total_ws_upgrades,
+                    "paths": ws_paths,
+                    "messages_in_total": self.ws_messages_in,
+                    "messages_out_total": self.ws_messages_out,
+                    "bytes_in_total": self.ws_bytes_in,
+                    "bytes_out_total": self.ws_bytes_out,
+                },
+                "traffic": {
+                    "bytes_in_total": self.bytes_in,
+                    "bytes_out_total": self.bytes_out,
+                },
+                "errors": {
+                    "total": self.total_errors,
+                    "last": self.last_error,
+                },
+            }
+        return data
+
+    def stream_chunks(self, interval_seconds=1.0, max_points=None):
+        interval_seconds = _safe_float(interval_seconds, 1.0)
+        if interval_seconds < 0.1:
+            interval_seconds = 0.1
+        if interval_seconds > 60.0:
+            interval_seconds = 60.0
+        if max_points is not None:
+            max_points = _safe_int(max_points, None)
+            if max_points is not None and max_points <= 0:
+                max_points = None
+
+        sent = 0
+        while True:
+            payload = json.dumps(
+                self.snapshot(),
+                ensure_ascii=False,
+                separators=(",", ":"),
+            ).encode("utf-8") + b"\n"
+            yield payload
+            sent += 1
+            if max_points is not None and sent >= max_points:
+                break
+            time.sleep(interval_seconds)
+
+    def response_snapshot(self):
+        return Response.json(self.snapshot())
+
+    def response_stream(self, interval_seconds=1.0, max_points=None):
+        headers = {
+            "Cache-Control": "no-cache, no-store, must-revalidate",
+            "Pragma": "no-cache",
+            "Expires": "0",
+            "X-Accel-Buffering": "no",
+        }
+        return Response.stream(
+            self.stream_chunks(interval_seconds=interval_seconds, max_points=max_points),
+            content_type="application/x-ndjson; charset=utf-8",
+            headers=headers,
+        )
+
+
+def install_metrics(app, path="/api/metrics", stream_path="/api/metrics/stream", app_name=None):
+    name = app_name or app.__class__.__name__
+    metrics = AppMetrics(app_name=name)
+    app.metrics = metrics
+
+    @app.api(path, methods=("GET",))
+    def _metrics_snapshot(request):
+        return metrics.response_snapshot()
+
+    @app.api(stream_path, methods=("GET",))
+    def _metrics_stream(request):
+        interval = request.query.get("interval", "1.0")
+        limit_text = request.query.get("limit", "")
+        follow = request.query.get("follow", "")
+        if limit_text:
+            parsed = _safe_int(limit_text, DEFAULT_STREAM_POINTS)
+            if parsed <= 0:
+                max_points = None
+            else:
+                max_points = parsed
+        else:
+            if _is_truthy(follow):
+                max_points = None
+            else:
+                max_points = DEFAULT_STREAM_POINTS
+        return metrics.response_stream(interval_seconds=interval, max_points=max_points)
+
+    return metrics
+
+
+__all__ = ["AppMetrics", "install_metrics"]