wsbuilder 1.0.0__tar.gz → 1.0.2__tar.gz

{wsbuilder-1.0.0/src/wsbuilder.egg-info → wsbuilder-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wsbuilder
-Version: 1.0.0
+Version: 1.0.2
 Summary: Lightweight HTTP + WebSocket framework for Python.
 Author: wsbuilder Authors
 License-Expression: MIT

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/docs/getting-started.md

@@ -73,6 +73,7 @@ app.enable_docs()
 
 ```bash
 PYTHONPATH=src pytest -q
+ruff check src tests examples
 mkdocs build --strict
 python -m wsbuilder --host 0.0.0.0 --port 8765
 ```

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/docs/install.md

@@ -155,6 +155,7 @@ Validar el paquete:
 
 ```bash
 PYTHONPATH=src pytest -q
+ruff check src tests examples
 ```
 
 Validar la documentacion:

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wsbuilder"
-version = "1.0.0"
+version = "1.0.2"
 description = "Lightweight HTTP + WebSocket framework for Python."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -49,3 +49,23 @@ package-dir = {"" = "src"}
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["wsbuilder*"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP"]
+ignore = [
+  "E501",   # long literals and protocol tables read better unwrapped
+  "B905",   # zip() over equal-length vectors; strict= would change behaviour
+  "UP031",  # printf-style formatting is used deliberately in log templates
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Test closures defined in loops run and are joined within the same iteration.
+"tests/*" = ["B023"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["wsbuilder"]

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/__init__.py

@@ -1,19 +1,48 @@
 """wsbuilder: mini framework HTTP + WebSocket."""
 
+from .cache import Cache, SQLiteMemoryCache, install_cache
+from .caches import GlobalCacheRule, ViewResponseCache, install_caches
+from .cookies import build_set_cookie, get_cookie, parse_cookie_header
+from .db_replicas import (
+    DatabaseReplica,
+    DatabaseReplicaPool,
+    OptimizedDatabase,
+    SQLite3OptimizationConfig,
+)
+from .dns import LocalDNSServer
 from .framework import (
-    App,
-    HTTPServer,
-    Request,
-    Response,
-    Route,
-    Router,
-    WebSocket,
+    BALANCING_BEST,
+    BALANCING_CONSISTENT_HASH,
+    BALANCING_FIRST_AVAILABLE,
+    BALANCING_IP_HASH,
+    BALANCING_LEAST_BYTES_IN,
+    BALANCING_LEAST_BYTES_OUT,
+    BALANCING_LEAST_CONNECTIONS,
+    BALANCING_LEAST_REQUESTS,
+    BALANCING_LEAST_RESPONSE_TIME,
+    BALANCING_POWER_OF_TWO_CHOICES,
+    BALANCING_RANDOM,
+    BALANCING_ROUND_ROBIN,
+    BALANCING_WEIGHTED_ROUND_ROBIN,
+    SUPPORTED_BALANCING_STRATEGIES,
     TASK_CANCELLED,
     TASK_COMPLETED,
     TASK_FAILED,
     TASK_PENDING,
     TASK_REJECTED,
     TASK_RUNNING,
+    App,
+    HTTPServer,
+    ProxyI,
+    ProxyMetricsBucket,
+    ProxyRouteBuilder,
+    ProxyRule,
+    ProxyTarget,
+    Request,
+    Response,
+    Route,
+    Router,
+    RunningStats,
     TaskCancelledError,
     TaskClosedError,
     TaskContext,
@@ -21,44 +50,31 @@ from .framework import (
     TaskHandle,
     TaskManager,
     TaskRejectedError,
-    ProxyI,
-    proxyi,
-    ProxyRule,
-    ProxyRouteBuilder,
-    ProxyTarget,
-    ProxyMetricsBucket,
-    RunningStats,
+    WebSocket,
+    handshake_websocket_with_options,
     install_proxyi,
     normalize_balance_mode,
     normalize_target,
-    SUPPORTED_BALANCING_STRATEGIES,
-    BALANCING_ROUND_ROBIN,
-    BALANCING_WEIGHTED_ROUND_ROBIN,
-    BALANCING_RANDOM,
-    BALANCING_LEAST_CONNECTIONS,
-    BALANCING_LEAST_RESPONSE_TIME,
-    BALANCING_LEAST_REQUESTS,
-    BALANCING_LEAST_BYTES_IN,
-    BALANCING_LEAST_BYTES_OUT,
-    BALANCING_IP_HASH,
-    BALANCING_CONSISTENT_HASH,
-    BALANCING_FIRST_AVAILABLE,
-    BALANCING_POWER_OF_TWO_CHOICES,
-    BALANCING_BEST,
     parse_close_payload,
     parse_query_string,
-    handshake_websocket_with_options,
+    proxyi,
+)
+from .headers import get_header, has_header, normalize_header_name, set_header
+from .ia import (
+    DataSet,
+    DataSummary,
+    DenseLayer,
+    ErrorSummary,
+    NeuralNetwork,
+    describe_data,
+    evaluate_errors,
+    submit_training_task,
 )
-from .metrics import AppMetrics, install_metrics
 from .logs import NDJSONLog, install_logs
-from .cache import Cache, SQLiteMemoryCache, install_cache
-from .caches import GlobalCacheRule, ViewResponseCache, install_caches
-from .security import ACLRule, SecurityDecision, SecurityPolicy, install_security
-from .dns import LocalDNSServer
 from .mdns import LocalMDNSServer, MDNSService, discover_mdns_services
-from .cookies import build_set_cookie, get_cookie, parse_cookie_header
-from .headers import get_header, has_header, normalize_header_name, set_header
+from .metrics import AppMetrics, install_metrics
 from .orm import (
+    SQL,
     BlobField,
     BooleanField,
     Database,
@@ -69,7 +85,6 @@ from .orm import (
     Model,
     QuerySet,
     RealField,
-    SQL,
     TextField,
     Transaction,
     create_tables,
@@ -77,23 +92,8 @@ from .orm import (
     quote_identifier,
     validate_identifier,
 )
-from .db_replicas import (
-    DatabaseReplica,
-    DatabaseReplicaPool,
-    OptimizedDatabase,
-    SQLite3OptimizationConfig,
-)
-from .ia import (
-    DataSet,
-    DataSummary,
-    DenseLayer,
-    ErrorSummary,
-    NeuralNetwork,
-    describe_data,
-    evaluate_errors,
-    submit_training_task,
-)
 from .predicts import Predictor
+from .security import ACLRule, SecurityDecision, SecurityPolicy, install_security
 
 #: Names served from wsbuilder.pki, which needs the optional `tls` extra.
 _PKI_EXPORTS = frozenset(
@@ -126,7 +126,7 @@ def __getattr__(name):
 def __dir__():
     return sorted(set(globals()) | _PKI_EXPORTS)
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 
 __all__ = [
     "App",

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/app.py

@@ -431,7 +431,7 @@ class App:
 
     def _sign_thread_cookie(self, route_path, thread_id, issued_at=None):
         issued = int(time.time() if issued_at is None else issued_at)
-        payload = f"{route_path}|{thread_id}|{issued}".encode("utf-8")
+        payload = f"{route_path}|{thread_id}|{issued}".encode()
         sig = hmac.new(
             self._thread_cookie_secret,
             payload,
@@ -467,7 +467,7 @@ class App:
         ttl = max(0.0, float(ttl_seconds or 0.0))
         if issued > now + 60 or (ttl > 0 and now - issued > ttl):
             return ""
-        payload = f"{route_path}|{normalized}|{issued}".encode("utf-8")
+        payload = f"{route_path}|{normalized}|{issued}".encode()
         expected = hmac.new(
             self._thread_cookie_secret,
             payload,

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/cookies.py

@@ -2,7 +2,6 @@ import re
 
 from .headers import get_header
 
-
 _COOKIE_NAME_RE = re.compile(r"^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$")
 _COOKIE_VALUE_RE = re.compile(r'^[\x21\x23-\x2B\x2D-\x3A\x3C-\x5B\x5D-\x7E]*$')
 _SAME_SITE_VALUES = {

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/db_replicas.py

@@ -4,47 +4,46 @@ from __future__ import annotations
 
 import sqlite3
 import threading
-from typing import Optional
 from dataclasses import dataclass
 
 
 @dataclass
 class SQLite3OptimizationConfig:
     """Configuration for SQLite3 optimizations."""
-    
+
     # WAL mode - enables multiple readers
     journal_mode: str = "WAL"
-    
+
     # Memory budget in KiB used with PRAGMA cache_size < 0.
     cache_size: int = 10000
-    
+
     # Synchronization level (FULL=safer, NORMAL=faster)
     synchronous: str = "NORMAL"
-    
+
     # Temp store location
     temp_store: str = "MEMORY"
-    
+
     # Query timeout
     busy_timeout: float = 10.0
-    
+
     # Enable memory-mapped I/O
     mmap_size: int = 30000000  # 30MB
-    
+
     # Optimization settings
     optimize: bool = True
     automatic_indexing: bool = True
     query_only: bool = False
-    
+
     # Foreign keys enforcement
     foreign_keys: bool = True
-    
+
     # Checkpoint settings for WAL
     wal_autocheckpoint: int = 1000  # Pages before auto-checkpoint
 
 
 class DatabaseReplica:
     """Represents a read-only replica of the database."""
-    
+
     def __init__(
         self,
         db_path: str,
@@ -55,9 +54,9 @@ class DatabaseReplica:
         self.db_path = db_path
         self.timeout = timeout
         self.detect_types = detect_types
-        self._conn: Optional[sqlite3.Connection] = None
+        self._conn: sqlite3.Connection | None = None
         self._lock = threading.RLock()
-    
+
     def connect(self) -> sqlite3.Connection:
         """Get or create read-only connection."""
         with self._lock:
@@ -73,14 +72,14 @@ class DatabaseReplica:
                 # Read-only optimization
                 self._conn.execute("PRAGMA query_only = ON")
             return self._conn
-    
+
     def close(self):
         """Close the replica connection."""
         with self._lock:
             if self._conn:
                 self._conn.close()
                 self._conn = None
-    
+
     def execute(self, sql: str, params=None):
         """Execute a read-only query."""
         conn = self.connect()
@@ -88,17 +87,17 @@ class DatabaseReplica:
             params = ()
         with self._lock:
             return conn.execute(sql, tuple(params))
-    
+
     def fetchone(self, sql: str, params=None):
         """Fetch one result."""
         with self._lock:
             return self.execute(sql, params).fetchone()
-    
+
     def fetchall(self, sql: str, params=None):
         """Fetch all results."""
         with self._lock:
             return self.execute(sql, params).fetchall()
-    
+
     def scalar(self, sql: str, params=None, default=None):
         """Fetch a scalar value."""
         with self._lock:
@@ -110,7 +109,7 @@ class DatabaseReplica:
 
 class DatabaseReplicaPool:
     """Pool of read-only database replicas with round-robin distribution."""
-    
+
     def __init__(
         self,
         db_path: str,
@@ -125,7 +124,7 @@ class DatabaseReplicaPool:
         self.replica_count = replica_count
         self.timeout = timeout
         self.detect_types = detect_types
-        
+
         self._replicas = [
             DatabaseReplica(
                 db_path,
@@ -136,34 +135,34 @@ class DatabaseReplicaPool:
         ]
         self._current_index = 0
         self._lock = threading.RLock()
-    
+
     def get_replica(self) -> DatabaseReplica:
         """Get the next replica in round-robin fashion."""
         with self._lock:
             replica = self._replicas[self._current_index]
             self._current_index = (self._current_index + 1) % len(self._replicas)
             return replica
-    
+
     def execute(self, sql: str, params=None):
         """Execute query on a replica."""
         replica = self.get_replica()
         return replica.execute(sql, params)
-    
+
     def fetchone(self, sql: str, params=None):
         """Fetch one result from a replica."""
         replica = self.get_replica()
         return replica.fetchone(sql, params)
-    
+
     def fetchall(self, sql: str, params=None):
         """Fetch all results from a replica."""
         replica = self.get_replica()
         return replica.fetchall(sql, params)
-    
+
     def scalar(self, sql: str, params=None, default=None):
         """Fetch scalar from a replica."""
         replica = self.get_replica()
         return replica.scalar(sql, params, default)
-    
+
     def close_all(self):
         """Close all replica connections."""
         for replica in self._replicas:
@@ -179,7 +178,7 @@ def _pragma_cache_size_from_kib(size_kib: int) -> int:
 
 class OptimizedDatabase:
     """SQLite3 database with built-in optimizations."""
-    
+
     def __init__(
         self,
         path: str = ":memory:",
@@ -198,7 +197,7 @@ class OptimizedDatabase:
         self._tx_depth = threading.local()
         self._savepoint_sequence = 0
         self.optimization_config = optimization_config or SQLite3OptimizationConfig()
-        
+
         # Connection setup
         if shared_cache:
             dsn = "file::memory:?cache=shared" if path == ":memory:" else path
@@ -216,14 +215,14 @@ class OptimizedDatabase:
                 timeout=timeout,
                 detect_types=detect_types,
             )
-        
+
         self._conn.row_factory = sqlite3.Row
-        
+
         # Apply SQLite3 optimizations
         self._apply_optimizations(timeout, pragmas)
-        
+
         # Setup read replicas if enabled
-        self._replicas: Optional[DatabaseReplicaPool] = None
+        self._replicas: DatabaseReplicaPool | None = None
         if enable_replicas and path != ":memory:":
             self._replicas = DatabaseReplicaPool(
                 path,
@@ -231,11 +230,11 @@ class OptimizedDatabase:
                 timeout=timeout,
                 detect_types=detect_types,
             )
-    
+
     def _apply_optimizations(self, timeout: float, custom_pragmas: dict | None):
         """Apply SQLite3 optimization pragmas."""
         config = self.optimization_config
-        
+
         base_pragmas = {
             "journal_mode": config.journal_mode,
             "cache_size": _pragma_cache_size_from_kib(config.cache_size),
@@ -247,25 +246,25 @@ class OptimizedDatabase:
             "query_only": 1 if config.query_only else 0,
             "automatic_index": 1 if config.automatic_indexing else 0,
         }
-        
+
         if custom_pragmas:
             base_pragmas.update(custom_pragmas)
-        
+
         with self._lock:
             for key, value in base_pragmas.items():
                 self._log(f"PRAGMA {key}={value}")
                 self._conn.execute(f"PRAGMA {key}={value}")
-            
+
             # WAL checkpoint settings
             if config.journal_mode.upper() == "WAL":
                 self._log(f"PRAGMA wal_autocheckpoint={config.wal_autocheckpoint}")
                 self._conn.execute(f"PRAGMA wal_autocheckpoint={config.wal_autocheckpoint}")
-            
+
             # Run optimization if enabled
             if config.optimize:
                 self._log("PRAGMA optimize")
                 self._conn.execute("PRAGMA optimize")
-    
+
     def _log(self, *parts):
         if self.debug:
             print("[DB]", *parts)

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/dns.py

@@ -2,7 +2,6 @@ import base64
 import socket
 import threading
 
-
 QTYPE_A = 1
 QTYPE_NS = 2
 QTYPE_CNAME = 5
@@ -1028,7 +1027,7 @@ class LocalDNSServer:
             while self._running.is_set():
                 try:
                     data, addr = self._sock.recvfrom(4096)
-                except socket.timeout:
+                except TimeoutError:
                     continue
                 except OSError:
                     if self._running.is_set():

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/headers.py

@@ -1,6 +1,5 @@
 import re
 
-
 _HEADER_NAME_RE = re.compile(r"^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$")
 
 

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/http.py

@@ -5,7 +5,6 @@ from urllib.parse import parse_qsl
 from .constants import STATUS_MESSAGES
 from .headers import validate_header_name, validate_header_value
 
-
 MAX_QUERY_FIELDS = 1024
 HTTP_0_9 = "HTTP/0.9"
 HTTP_1_1 = "HTTP/1.1"
@@ -281,7 +280,7 @@ def send_http_response(conn, response, *, send_body=True, keep_alive=False, vers
             use_chunked = "chunked" in lowermap.get("transfer-encoding", "").lower()
             for chunk in _iter_stream_chunks(response.stream):
                 if use_chunked:
-                    conn.sendall(f"{len(chunk):X}\r\n".encode("utf-8"))
+                    conn.sendall(f"{len(chunk):X}\r\n".encode())
                     conn.sendall(chunk)
                     conn.sendall(b"\r\n")
                 else:

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/http3_server.py

@@ -19,7 +19,7 @@ from cryptography.hazmat.primitives import serialization
 from . import http3
 from .http3_websocket import Http3WebSocketStream
 from .quic.address import AddressValidator
-from .quic.connection import MAX_DATAGRAM_SIZE, QuicConnection
+from .quic.connection import QuicConnection
 from .quic.crypto import retry_integrity_tag
 from .quic.packet import (
     PACKET_INITIAL,
@@ -28,7 +28,6 @@ from .quic.packet import (
     new_connection_id,
     parse_long_header,
 )
-from .quic.varint import decode_varint
 
 DEFAULT_MAX_CONNECTIONS = 256
 
@@ -106,7 +105,7 @@ class Http3Server:
             while not self._stop.is_set():
                 try:
                     datagram, address = sock.recvfrom(65535)
-                except socket.timeout:
+                except TimeoutError:
                     # The idle gap is where loss timers get a chance to fire;
                     # without this a probe would wait for the next datagram,
                     # which on a lossy path may never come.

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/http3_websocket.py

@@ -8,7 +8,6 @@ those. Bytes the peer sends are pushed in by the thread that owns the UDP
 socket; bytes this side sends are queued for that same thread to packetize.
 """
 
-import socket
 import threading
 import time
 
@@ -60,7 +59,7 @@ class Http3WebSocketStream:
                 if deadline is not None:
                     remaining = deadline - time.monotonic()
                     if remaining <= 0:
-                        raise socket.timeout("timed out")
+                        raise TimeoutError("timed out")
                 self._cond.wait(remaining)
             if self._buffer:
                 chunk = bytes(self._buffer[:n])

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/mdns.py

@@ -7,10 +7,9 @@ import re
 import socket
 import threading
 import time
+from collections.abc import Mapping
 from dataclasses import dataclass
 from types import MappingProxyType
-from typing import Mapping
-
 
 DEFAULT_SERVICE_TYPE = "_http._tcp.local."
 

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/orm.py

@@ -316,29 +316,29 @@ class Database:
             )
 
         self._conn.row_factory = sqlite3.Row
-        
+
         # Default optimized pragmas
         base_pragmas = {
             "foreign_keys": 1,
             "busy_timeout": int(timeout * 1000),
         }
-        
+
         # Add SQLite3 optimizations
         if enable_wal:
             base_pragmas["journal_mode"] = "WAL"
             base_pragmas["wal_autocheckpoint"] = 1000
-        
+
         base_pragmas["cache_size"] = _pragma_cache_size_from_mb(cache_size_mb)
         base_pragmas["synchronous"] = "NORMAL"
         base_pragmas["temp_store"] = "MEMORY"
         base_pragmas["mmap_size"] = 30000000
         base_pragmas["automatic_index"] = 1
-        
+
         if pragmas:
             base_pragmas.update(pragmas)
         for key, value in base_pragmas.items():
             self.set_pragma(key, value)
-        
+
         # Enable read replicas if needed
         if enable_replicas and path != ":memory:":
             from . import db_replicas

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/pki.py

@@ -32,7 +32,7 @@ from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import ec, rsa
 from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
 
-UTC = _datetime.timezone.utc
+UTC = _datetime.UTC
 
 DEFAULT_CA_VALID_DAYS = 3650
 DEFAULT_LEAF_VALID_DAYS = 397

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/predicts.py

@@ -18,7 +18,6 @@ from __future__ import annotations
 
 import math
 
-
 _RANK_TOLERANCE = 1e-12
 
 

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/proxyi.py

@@ -839,7 +839,7 @@ class ProxyRule:
         return rows[0][4]
 
     def _hash_score(self, key, target):
-        raw = f"{key}|{target.url}|{target.name}".encode("utf-8")
+        raw = f"{key}|{target.url}|{target.name}".encode()
         digest = hashlib.sha256(raw).digest()
         value = int.from_bytes(digest[:8], byteorder="big", signed=False)
         weight = max(1, int(getattr(target, "weight", 1) or 1))

{wsbuilder-1.0.0 → wsbuilder-1.0.2}/src/wsbuilder/quic/address.py

@@ -44,7 +44,7 @@ class AddressValidator:
     @staticmethod
     def _address_bytes(address):
         host, port = address
-        return f"{host}|{int(port)}".encode("utf-8")
+        return f"{host}|{int(port)}".encode()
 
     def issue(self, address, original_destination_cid):
         """Mint a token tied to this address and the client's first id."""