pyweb-stack 0.1.0__py3-none-any.whl

pyweb/models.py

@@ -0,0 +1,269 @@
+"""Model layer: annotation-style prototype models plus typed Field models
+bound to a database driver (SQLite/Postgres)."""
+
+from __future__ import annotations
+
+import sqlite3
+import threading
+from typing import ClassVar
+
+_lock = threading.RLock()
+_db_path = ":memory:"
+_conns: dict[str, sqlite3.Connection] = {}
+
+
+class Email(str):
+    @classmethod
+    def validate(cls, value):
+        if "@" not in str(value):
+            raise ValueError(f"invalid email: {value!r}")
+        return cls(value)
+
+
+class Field:
+    column_type = "TEXT"
+
+    def __init__(self, *, primary_key=False, nullable=True, default=None):
+        self.primary_key = primary_key
+        self.nullable = nullable
+        self.default = default
+        self.name = ""
+
+    def sql(self):
+        parts = [self.name, self.column_type]
+        if self.primary_key:
+            parts.append("PRIMARY KEY")
+            if self.column_type == "INTEGER":
+                parts.append("AUTOINCREMENT")
+        elif not self.nullable:
+            parts.append("NOT NULL")
+        if self.default is not None and not self.primary_key:
+            parts.append(f"DEFAULT {self._default_sql()}")
+        return " ".join(parts)
+
+    def _default_sql(self):
+        if isinstance(self.default, str):
+            return "'" + self.default.replace("'", "''") + "'"
+        if isinstance(self.default, bool):
+            return "1" if self.default else "0"
+        return str(self.default)
+
+    def to_db(self, value):
+        return value
+
+    def from_db(self, value):
+        return value
+
+
+class IntegerField(Field):
+    column_type = "INTEGER"
+
+
+class TextField(Field):
+    column_type = "TEXT"
+
+
+class RealField(Field):
+    column_type = "REAL"
+
+
+class BlobField(Field):
+    column_type = "BLOB"
+
+
+class ModelMeta(type):
+    _registry: list[type] = []
+
+    def __new__(mcls, name, bases, ns):
+        fields: dict[str, Field] = {}
+        for base in bases:
+            if hasattr(base, "__fields__") and isinstance(getattr(base, "__fields__"), dict):
+                for k, f in getattr(base, "__fields__").items():
+                    if isinstance(f, Field):
+                        fields[k] = f
+        annotations = ns.get("__annotations__", {})
+        cls = super().__new__(mcls, name, bases, ns)
+        if name != "Model":
+            cls._fields = dict(annotations)
+            for key, val in list(ns.items()):
+                if isinstance(val, Field):
+                    val.name = key
+                    fields[key] = val
+            if fields:
+                cls.__fields__ = fields
+                if "__table__" not in ns:
+                    cls.__table__ = name.lower()
+                pks = [k for k, f in fields.items() if f.primary_key]
+                cls.__pk__ = pks[0] if pks else None
+            elif "__fields__" not in ns:
+                cls.__fields__ = {}
+            ModelMeta._registry.append(cls)
+        return cls
+
+
+class Model(metaclass=ModelMeta):
+    _fields: dict = {}
+    _table: str = ""
+    __fields__: ClassVar[dict] = {}
+    __table__: ClassVar[str] = ""
+    __pk__: ClassVar[str | None] = None
+    _db: ClassVar = None
+
+    def __init__(self, **kwargs):
+        if getattr(type(self), "__fields__", {}):
+            for key, field in type(self).__fields__.items():
+                setattr(self, key, kwargs.pop(key, field.default))
+            if kwargs:
+                raise TypeError(f"unknown fields for {type(self).__name__}: {sorted(kwargs)}")
+        else:
+            for k, v in kwargs.items():
+                setattr(self, k, v)
+
+    @classmethod
+    def bind(cls, db):
+        cls._db = db
+        return db
+
+    @classmethod
+    def _db_or_raise(cls):
+        if cls._db is None:
+            raise RuntimeError(f"{cls.__name__} is not bound to a database; "
+                               f"call {cls.__name__}.bind(db) first")
+        return cls._db
+
+    def to_dict(self):
+        if getattr(type(self), "__fields__", {}):
+            return {k: getattr(self, k) for k in type(self).__fields__}
+        return dict(self.__dict__)
+
+    @classmethod
+    def schema_sql(cls):
+        cols = ", ".join(f.sql() for f in cls.__fields__.values())
+        return f"CREATE TABLE IF NOT EXISTS {cls.__table__} ({cols})"
+
+    @classmethod
+    def _from_row(cls, row, columns):
+        obj = cls.__new__(cls)
+        for col, val in zip(columns, row):
+            field = cls.__fields__.get(col)
+            setattr(obj, col, field.from_db(val) if field else val)
+        return obj
+
+    def save(self):
+        from pyweb.db import Query
+        db = self._db_or_raise()
+        data = {k: f.to_db(getattr(self, k)) for k, f in type(self).__fields__.items()
+                if not (f.primary_key and getattr(self, k) is None)}
+        pk = type(self).__pk__
+        if pk is not None and getattr(self, pk) is not None:
+            assignments = {k: v for k, v in data.items() if k != pk}
+            if assignments:
+                q = Query(type(self).__table__).where(**{pk: getattr(self, pk)})
+                sql, params = q.build_update(assignments)
+                db.execute(sql, params)
+        else:
+            sql, params = Query(type(self).__table__).build_insert(data)
+            result = db.execute(sql, params)
+            if pk is not None and getattr(self, pk) is None:
+                setattr(self, pk, result.lastrowid)
+        return self
+
+    def delete(self):
+        from pyweb.db import Query
+        db = self._db_or_raise()
+        pk = type(self).__pk__
+        if pk is None or getattr(self, pk) is None:
+            raise ValueError("cannot delete a model without a primary key value")
+        q = Query(type(self).__table__).where(**{pk: getattr(self, pk)})
+        sql, params = q.build_delete()
+        db.execute(sql, params)
+
+    @classmethod
+    def get(cls, pk_value):
+        from pyweb.db import Query
+        db = cls._db_or_raise()
+        q = Query(cls.__table__).where(**{cls.__pk__: pk_value})
+        sql, params = q.build_select()
+        res = db.execute(sql, params)
+        rows = res.fetchall()
+        if not rows:
+            return None
+        return cls._from_row(rows[0], res.columns)
+
+    @classmethod
+    def filter(cls, **kwargs):
+        from pyweb.db import Query
+        db = cls._db_or_raise()
+        q = Query(cls.__table__).where(**kwargs)
+        sql, params = q.build_select()
+        res = db.execute(sql, params)
+        return [cls._from_row(r, res.columns) for r in res.fetchall()]
+
+    @classmethod
+    def _conn(cls):
+        global _db_path
+        key = _db_path
+        with _lock:
+            if key not in _conns:
+                _conns[key] = sqlite3.connect(key, check_same_thread=False)
+                _conns[key].row_factory = sqlite3.Row
+            return _conns[key]
+
+    @classmethod
+    def configure(cls, path=":memory:"):
+        global _db_path
+        _db_path = path
+
+    @classmethod
+    def table(cls):
+        return cls._table or cls.__name__.lower() + "s"
+
+    @classmethod
+    def migrate(cls):
+        cols = []
+        for name, ann in cls._fields.items():
+            tname = getattr(ann, "__name__", "TEXT").upper()
+            sql_t = {"STR": "TEXT", "INT": "INTEGER", "FLOAT": "REAL", "BOOL": "INTEGER"}.get(tname, "TEXT")
+            cols.append(f'"{name}" {sql_t}')
+        conn = cls._conn()
+        with _lock:
+            conn.execute(f'CREATE TABLE IF NOT EXISTS "{cls.table()}" (id INTEGER PRIMARY KEY AUTOINCREMENT, {", ".join(cols)})')
+            conn.commit()
+
+    @classmethod
+    def create(cls, **kwargs):
+        if getattr(cls, "__fields__", {}):
+            return cls(**kwargs).save()
+        cls.migrate()
+        conn = cls._conn()
+        keys = list(kwargs)
+        with _lock:
+            cur = conn.execute(
+                f'INSERT INTO "{cls.table()}" ({", ".join(keys)}) VALUES ({", ".join("?" for _ in keys)})',
+                [kwargs[k] for k in keys],
+            )
+            conn.commit()
+            return {"id": cur.lastrowid, **kwargs}
+
+    @classmethod
+    def all(cls):
+        if getattr(cls, "__fields__", {}):
+            from pyweb.db import Query
+            db = cls._db_or_raise()
+            sql, params = Query(cls.__table__).build_select()
+            res = db.execute(sql, params)
+            return [cls._from_row(r, res.columns) for r in res.fetchall()]
+        cls.migrate()
+        conn = cls._conn()
+        with _lock:
+            return [dict(r) for r in conn.execute(f'SELECT * FROM "{cls.table()}"')]
+
+    @classmethod
+    def where(cls, **kwargs):
+        cls.migrate()
+        conn = cls._conn()
+        with _lock:
+            if not kwargs:
+                return cls.all()
+            cond = " AND ".join(f'"{k}" = ?' for k in kwargs)
+            return [dict(r) for r in conn.execute(f'SELECT * FROM "{cls.table()}" WHERE {cond}', list(kwargs.values()))]

pyweb/npm.py

@@ -0,0 +1,270 @@
+"""npm interop stub: typed package references + .d.ts binding sketch."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def package(name: str, version: str = "latest"):
+    return {"npm": name, "version": version, "kind": "esm"}
+
+
+_TS_SCALARS = {"number": "float", "string": "str", "boolean": "bool",
+               "any": "object", "unknown": "object", "void": "None",
+               "null": "None", "undefined": "None", "Date": "str"}
+
+
+def _ts_to_py(ts_type):
+    import re
+    t = ts_type.strip().rstrip(";").strip()
+    if t.endswith("[]"):
+        return f"list[{_ts_to_py(t[:-2])}]"
+    m = re.match(r"Array<(.+)>", t)
+    if m:
+        return f"list[{_ts_to_py(m.group(1))}]"
+    if "|" in t:
+        parts = [_ts_to_py(p) for p in t.split("|")]
+        parts = [p for p in parts if p != "None"]
+        if len(parts) != len(t.split("|")):
+            return f"Optional[{' | '.join(parts) if parts else 'object'}]"
+        return " | ".join(parts) if parts else "object"
+    m = re.match(r"Record<(.+),\s*(.+)>", t)
+    if m:
+        return f"dict[{_ts_to_py(m.group(1))}, {_ts_to_py(m.group(2))}]"
+    return _TS_SCALARS.get(t, t)
+
+
+def from_dts(dts: str):
+    """Parse `interface`/`type` declarations into typed Python dataclasses."""
+    import re
+    out = ["from __future__ import annotations", "from dataclasses import dataclass",
+           "from typing import Optional", ""]
+    found = False
+    for m in re.finditer(r"(?:interface|type)\s+(\w+)(?:\s*=\s*)?\s*\{([^}]*)\}", dts):
+        found = True
+        name, body = m.group(1), m.group(2)
+        out.append("@dataclass")
+        out.append(f"class {name}:")
+        n_fields = 0
+        for line in body.splitlines():
+            line = line.split("//")[0].strip().rstrip(",;")
+            fm = re.match(r"(?:readonly\s+)?(\w+)(\?)?:\s*(.+)", line)
+            if fm:
+                fname, opt, ftype = fm.group(1), fm.group(2), fm.group(3).strip()
+                py_t = _ts_to_py(ftype)
+                out.append(f"    {fname}: {py_t} = None" if opt else f"    {fname}: {py_t}")
+                n_fields += 1
+        if not n_fields:
+            out.append("    pass")
+        out.append("")
+    for m in re.finditer(r"type\s+(\w+)\s*=\s*([^;]+);", dts):
+        if m.group(1) not in dts:
+            out.append(f"{m.group(1)} = {_ts_to_py(m.group(2))}")
+    return "\n".join(out) if found else "\n".join(out)
+
+
+@dataclass
+class DtsField:
+    name: str
+    ts_type: str
+    py_type: str
+    optional: bool
+    nested: str | None = None
+
+
+@dataclass
+class DtsInterface:
+    name: str
+    base: str | None
+    fields: list = field(default_factory=list)
+
+
+_INTERFACE_RE = None
+_FIELD_RE = None
+
+
+def _get_interface_re():
+    import re as _re
+    global _INTERFACE_RE
+    if _INTERFACE_RE is None:
+        _INTERFACE_RE = _re.compile(
+            r"interface\s+(?P<name>[A-Za-z_][\w]*)\s*"
+            r"(?:extends\s+(?P<base>[A-Za-z_][\w]*))?\s*\{(?P<body>[^}]*)\}",
+            _re.DOTALL)
+    return _INTERFACE_RE
+
+
+def _get_field_re():
+    import re as _re
+    global _FIELD_RE
+    if _FIELD_RE is None:
+        _FIELD_RE = _re.compile(
+            r"(?P<name>[A-Za-z_][\w]*)(?P<opt>\?)?\s*:\s*(?P<type>[^;,\n]+)\s*;?,?\s*$")
+    return _FIELD_RE
+
+
+def _ts_to_py_typed(ts_type, known):
+    import re as _re
+    _KNOWN_SCALARS = {"string": "str", "number": "float", "boolean": "bool",
+                      "any": "Any", "unknown": "Any", "void": "None",
+                      "null": "None", "undefined": "None", "object": "dict"}
+    t = ts_type.strip()
+    nested = None
+
+    def scalar(tok):
+        tok = tok.strip()
+        if (tok.startswith('"') and tok.endswith('"')) or (
+                tok.startswith("'") and tok.endswith("'")):
+            return "str"
+        if tok in _KNOWN_SCALARS:
+            return _KNOWN_SCALARS[tok]
+        if _re.fullmatch(r"-?\d+", tok):
+            return "int"
+        if _re.fullmatch(r"-?\d*\.\d+", tok):
+            return "float"
+        if tok in known:
+            return tok
+        return "Any"
+
+    m = _re.fullmatch(r"Array\s*<\s*(.+)\s*>", t)
+    if m:
+        inner, nested = _ts_to_py_typed(m.group(1), known)
+        return f"list[{inner}]", nested
+    while t.endswith("[]"):
+        t = t[:-2].strip()
+        inner, nested = _ts_to_py_typed(t, known)
+        return f"list[{inner}]", nested
+    if "|" in t:
+        parts = [p.strip() for p in t.split("|")]
+        parts = [p for p in parts if p not in ("undefined", "null")]
+        if parts and all((p.startswith('"') or p.startswith("'")) for p in parts):
+            return "str", None
+        if len(parts) == 1:
+            return _ts_to_py_typed(parts[0], known)
+        non_any = [scalar(p) for p in parts if scalar(p) != "Any"]
+        if len(non_any) == 1:
+            return non_any[0], (non_any[0] if non_any[0] in known else None)
+        return "Any", None
+    base = scalar(t)
+    if base in known:
+        nested = base
+    return base, nested
+
+
+def parse_dts(source):
+    found = list(_get_interface_re().finditer(source))
+    known = {m.group("name") for m in found}
+    out = []
+    for m in found:
+        iface = DtsInterface(name=m.group("name"), base=m.group("base"))
+        for raw_line in m.group("body").splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("//"):
+                continue
+            fm = _get_field_re().match(line)
+            if not fm:
+                continue
+            py_type, nested = _ts_to_py_typed(fm.group("type"), known)
+            iface.fields.append(DtsField(
+                name=fm.group("name"), ts_type=fm.group("type").strip(),
+                py_type=py_type, optional=bool(fm.group("opt")), nested=nested))
+        out.append(iface)
+    return out
+
+
+def _coerce_typed(nested, py_type, value_expr):
+    if nested is None:
+        return value_expr
+    if py_type.startswith("list["):
+        return (f"[{nested}.from_dict(v) if isinstance(v, dict) else v "
+                f"for v in {value_expr}]")
+    return (f"{nested}.from_dict({value_expr}) "
+            f"if isinstance({value_expr}, dict) else {value_expr}")
+
+
+def generate_stub(interfaces):
+    lines = [
+        '"""Generated stubs - do not edit. Source: .d.ts via pyweb npm.',
+        "",
+        "Regenerate with: pyweb npm <file.d.ts> [-o out.py]",
+        '"""',
+        "from __future__ import annotations",
+        "",
+        "from dataclasses import dataclass",
+        "from typing import Any, Optional",
+        "",
+        "",
+    ]
+    known = {i.name for i in interfaces}
+    for base in dict.fromkeys(i.base for i in interfaces if i.base and i.base not in known):
+        lines += ["@dataclass", f"class {base}:", "    pass", "", ""]
+    for iface in interfaces:
+        base = f"({iface.base})" if iface.base else ""
+        lines.append("@dataclass")
+        lines.append(f"class {iface.name}{base}:")
+        fields = sorted(iface.fields, key=lambda f: f.optional)
+        if not fields and not iface.base:
+            lines.append("    pass")
+        else:
+            for f in fields:
+                ann = f"Optional[{f.py_type}]" if f.optional else f.py_type
+                default = " = None" if f.optional else ""
+                lines.append(f"    {f.name}: {ann}{default}")
+        lines.append("")
+        lines.append("    @classmethod")
+        lines.append(f"    def from_dict(cls, data: dict) -> {iface.name}:")
+        lines.append("        if not isinstance(data, dict):")
+        lines.append(f'            raise TypeError(f"{iface.name} must be a dict")')
+        lines.append("        kwargs: dict[str, Any] = {}")
+        for f in fields:
+            if f.optional:
+                val = _coerce_typed(f.nested, f.py_type, f"data[{f.name!r}]")
+                lines.append(f"        if data.get({f.name!r}) is not None:")
+                lines.append(f"            kwargs[{f.name!r}] = {val}")
+            else:
+                val = _coerce_typed(f.nested, f.py_type, "_v")
+                lines.append(f"        if {f.name!r} not in data:")
+                lines.append(f'            raise TypeError(f"{iface.name} missing required field: {f.name}")')
+                lines.append(f"        _v = data[{f.name!r}]")
+                lines.append(f"        kwargs[{f.name!r}] = {val}")
+        lines.append("        try:")
+        lines.append("            return cls(**kwargs)")
+        lines.append("        except TypeError as exc:")
+        lines.append(f'            raise TypeError(f"invalid {iface.name}: {{exc}}") from exc')
+        lines.append("")
+        lines.append("")
+        lines.append(f"def validate_{iface.name}(data: dict) -> {iface.name}:")
+        lines.append(f'    """Validate a dict against {iface.name}; raise TypeError if invalid."""')
+        lines.append(f"    return {iface.name}.from_dict(data)")
+        lines.append("")
+        lines.append("")
+    return "\n".join(lines).rstrip("\n") + "\n"
+
+
+def generate_stubs_from_file(dts_path, out_path=None):
+    source = Path(dts_path).read_text(encoding="utf-8")
+    code = generate_stub(parse_dts(source))
+    if out_path is not None:
+        Path(out_path).write_text(code, encoding="utf-8")
+    return code
+
+
+def npm_main(argv=None):
+    import argparse
+    ap = argparse.ArgumentParser(prog="pyweb npm",
+                                 description="Generate typed Python stubs from .d.ts")
+    ap.add_argument("dts", help="Input .d.ts file")
+    ap.add_argument("-o", "--out", default=None,
+                    help="Write stubs to file (default: stdout)")
+    args = ap.parse_args(argv)
+    try:
+        code = generate_stubs_from_file(args.dts, args.out)
+    except FileNotFoundError:
+        print(f"npm: {args.dts}: file not found")
+        return 1
+    if args.out:
+        print(f"npm: wrote {args.out}")
+    else:
+        print(code, end="")
+    return 0