hookly 0.1.0__py3-none-any.whl

hookly/__init__.py

@@ -0,0 +1,25 @@
+"""
+Hookly — batteries-included backend toolkit for Python.
+
+Instead of wiring up a DB layer, a CRM module and an API router by hand,
+you import Hookly and call it.
+
+    from hookly import Database, CRM, API
+
+    db = Database("app.db")
+    crm = CRM(db)
+    api = API("my-service")
+
+    @api.get("/contacts")
+    def list_contacts():
+        return crm.list_contacts()
+
+    api.run(port=8000)
+"""
+
+from .db import Database
+from .crm import CRM
+from .api import API
+
+__version__ = "0.1.0"
+__all__ = ["Database", "CRM", "API", "__version__"]

hookly/api/__init__.py

@@ -0,0 +1,3 @@
+from .core import API
+
+__all__ = ["API"]

hookly/api/core.py

@@ -0,0 +1,70 @@
+"""
+hookly.api — a tiny decorator-based JSON API router.
+
+No dependencies, no config files: decorate a function, run the server.
+Good enough for internal tools and prototypes; swap in ASGI later for
+production if you outgrow it.
+"""
+
+from __future__ import annotations
+
+import json
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Callable
+
+
+class API:
+    """Call it, don't build it: a minimal HTTP router."""
+
+    def __init__(self, name: str = "hookly-api") -> None:
+        self.name = name
+        self._routes: dict[tuple[str, str], Callable] = {}
+
+    def route(self, path: str, method: str = "GET") -> Callable:
+        def decorator(func: Callable) -> Callable:
+            self._routes[(method.upper(), path)] = func
+            return func
+
+        return decorator
+
+    def get(self, path: str) -> Callable:
+        return self.route(path, "GET")
+
+    def post(self, path: str) -> Callable:
+        return self.route(path, "POST")
+
+    def run(self, host: str = "127.0.0.1", port: int = 8000) -> None:
+        routes = self._routes
+
+        class Handler(BaseHTTPRequestHandler):
+            def _handle(self, method: str) -> None:
+                handler = routes.get((method, self.path))
+                if handler is None:
+                    self.send_response(404)
+                    self.send_header("Content-Type", "application/json")
+                    self.end_headers()
+                    self.wfile.write(b'{"error": "not found"}')
+                    return
+                try:
+                    result = handler()
+                    body = json.dumps(result).encode()
+                    status = 200
+                except Exception as exc:  # noqa: BLE001 - surface errors as JSON
+                    body = json.dumps({"error": str(exc)}).encode()
+                    status = 500
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(body)
+
+            def do_GET(self) -> None:  # noqa: N802 - stdlib naming
+                self._handle("GET")
+
+            def do_POST(self) -> None:  # noqa: N802 - stdlib naming
+                self._handle("POST")
+
+            def log_message(self, format: str, *args) -> None:  # noqa: A002
+                pass  # keep the console quiet
+
+        print(f"⚡ {self.name} running at http://{host}:{port}")
+        HTTPServer((host, port), Handler).serve_forever()

hookly/crm/__init__.py

@@ -0,0 +1,3 @@
+from .core import CRM, Contact
+
+__all__ = ["CRM", "Contact"]

hookly/crm/core.py

@@ -0,0 +1,72 @@
+"""
+hookly.crm — a ready-made contacts/leads module.
+
+Drop it on top of any Database instance and you get a contacts table,
+lead statuses and simple queries for free.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Optional
+
+from ..db import Database
+
+
+@dataclass
+class Contact:
+    id: Optional[int]
+    name: str
+    phone: str = ""
+    email: str = ""
+    status: str = "new"  # new -> in_progress -> closed
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+class CRM:
+    """A small CRM: contacts in, statuses tracked, no setup required."""
+
+    STATUSES = ("new", "in_progress", "closed")
+
+    def __init__(self, db: Optional[Database] = None) -> None:
+        self.db = db or Database("hookly_crm.db")
+        self.db.create_table(
+            "contacts",
+            {
+                "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+                "name": "TEXT NOT NULL",
+                "phone": "TEXT",
+                "email": "TEXT",
+                "status": "TEXT DEFAULT 'new'",
+                "created_at": "TEXT",
+            },
+        )
+
+    def add_contact(self, name: str, phone: str = "", email: str = "") -> Contact:
+        contact = Contact(id=None, name=name, phone=phone, email=email)
+        contact.id = self.db.insert(
+            "contacts",
+            name=contact.name,
+            phone=contact.phone,
+            email=contact.email,
+            status=contact.status,
+            created_at=contact.created_at,
+        )
+        return contact
+
+    def list_contacts(self, status: Optional[str] = None) -> list[dict]:
+        if status:
+            return self.db.fetchall("SELECT * FROM contacts WHERE status = ?", (status,))
+        return self.db.fetchall("SELECT * FROM contacts ORDER BY id DESC")
+
+    def get_contact(self, contact_id: int) -> Optional[dict]:
+        return self.db.fetchone("SELECT * FROM contacts WHERE id = ?", (contact_id,))
+
+    def update_status(self, contact_id: int, status: str) -> None:
+        if status not in self.STATUSES:
+            raise ValueError(f"status must be one of {self.STATUSES}")
+        self.db.update("contacts", "id = ?", (contact_id,), status=status)
+
+    def delete_contact(self, contact_id: int) -> None:
+        self.db.delete("contacts", "id = ?", (contact_id,))

hookly/db/__init__.py

@@ -0,0 +1,3 @@
+from .sqlite import Database
+
+__all__ = ["Database"]

hookly/db/sqlite.py

@@ -0,0 +1,72 @@
+"""
+hookly.db — a SQLite layer with no ceremony.
+
+No models to declare, no migrations to write for simple cases: describe a
+table once, then insert/fetch with plain Python calls.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import Any, Iterable, Optional
+
+
+class Database:
+    """Thin, friendly wrapper around sqlite3."""
+
+    def __init__(self, path: str = "hookly.db") -> None:
+        self.path = path
+        self._conn = sqlite3.connect(self.path)
+        self._conn.row_factory = sqlite3.Row
+
+    # -- low level -----------------------------------------------------
+
+    def execute(self, query: str, params: Iterable[Any] = ()) -> sqlite3.Cursor:
+        cur = self._conn.execute(query, tuple(params))
+        self._conn.commit()
+        return cur
+
+    def fetchall(self, query: str, params: Iterable[Any] = ()) -> list[dict]:
+        cur = self._conn.execute(query, tuple(params))
+        return [dict(row) for row in cur.fetchall()]
+
+    def fetchone(self, query: str, params: Iterable[Any] = ()) -> Optional[dict]:
+        cur = self._conn.execute(query, tuple(params))
+        row = cur.fetchone()
+        return dict(row) if row else None
+
+    # -- convenience -----------------------------------------------------
+
+    def create_table(self, name: str, columns: dict[str, str]) -> None:
+        """create_table('users', {'id': 'INTEGER PRIMARY KEY', 'name': 'TEXT'})"""
+        cols_sql = ", ".join(f"{col} {ctype}" for col, ctype in columns.items())
+        self.execute(f"CREATE TABLE IF NOT EXISTS {name} ({cols_sql})")
+
+    def insert(self, table: str, **fields: Any) -> int:
+        """insert('users', name='Ali', email='ali@example.com') -> new row id"""
+        keys = ", ".join(fields.keys())
+        placeholders = ", ".join("?" for _ in fields)
+        cur = self.execute(
+            f"INSERT INTO {table} ({keys}) VALUES ({placeholders})",
+            tuple(fields.values()),
+        )
+        return cur.lastrowid
+
+    def update(self, table: str, where: str, where_params: Iterable[Any], **fields: Any) -> None:
+        set_sql = ", ".join(f"{k} = ?" for k in fields)
+        self.execute(
+            f"UPDATE {table} SET {set_sql} WHERE {where}",
+            tuple(fields.values()) + tuple(where_params),
+        )
+
+    def delete(self, table: str, where: str, where_params: Iterable[Any] = ()) -> None:
+        self.execute(f"DELETE FROM {table} WHERE {where}", where_params)
+
+    def close(self) -> None:
+        self._conn.close()
+
+    def __enter__(self) -> "Database":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()

hookly-0.1.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: hookly
+Version: 0.1.0
+Summary: Batteries-included backend toolkit for Python — API, DB and CRM, ready to call.
+Project-URL: Homepage, https://github.com/yourusername/hookly
+Project-URL: Repository, https://github.com/yourusername/hookly
+Project-URL: Issues, https://github.com/yourusername/hookly/issues
+Author-email: Your Name <you@example.com>
+License: MIT
+Keywords: api,backend,crm,framework,sqlite,toolkit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ⚡ Hookly
+
+**Batteries-included backend toolkit for Python.**
+Stop wiring up an API, a database layer and a CRM by hand — import Hookly and call it.
+
+![PyPI](https://img.shields.io/badge/pypi-hookly-blue)
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+---
+
+## Why Hookly
+
+Every backend needs the same handful of things: an API layer, a place to store
+data, and something to track contacts, leads or tickets. Hookly ships all
+three as ready-made modules that work together out of the box — you call
+them, you don't rebuild them.
+
+```python
+from hookly import Database, CRM, API
+
+db = Database("app.db")
+crm = CRM(db)
+api = API("my-service")
+
+@api.get("/contacts")
+def list_contacts():
+    return crm.list_contacts()
+
+@api.post("/contacts")
+def new_contact():
+    return crm.add_contact("Ali", phone="+998901234567").__dict__
+
+api.run(port=8000)
+```
+
+That's a working API + database + CRM. No boilerplate.
+
+---
+
+## Install
+
+```bash
+pip install hookly
+```
+
+(local dev: `pip install -e ".[dev]"` from the project root)
+
+---
+
+## Modules
+
+### `hookly.db` — SQLite without the ceremony
+
+```python
+from hookly import Database
+
+db = Database("app.db")
+db.create_table("users", {"id": "INTEGER PRIMARY KEY", "name": "TEXT"})
+db.insert("users", name="Ali")
+db.fetchall("SELECT * FROM users")
+```
+
+### `hookly.crm` — contacts and leads, ready to go
+
+```python
+from hookly import CRM
+
+crm = CRM()
+contact = crm.add_contact("Ali", email="ali@example.com")
+crm.update_status(contact.id, "in_progress")
+crm.list_contacts(status="in_progress")
+```
+
+### `hookly.api` — a tiny decorator-based router
+
+```python
+from hookly import API
+
+api = API("my-service")
+
+@api.get("/ping")
+def ping():
+    return {"status": "ok"}
+
+api.run(port=8000)
+```
+
+---
+
+## Roadmap
+
+- [ ] Async support (`AsyncDatabase`, `AsyncAPI`)
+- [ ] Auth module (`hookly.auth`)
+- [ ] PostgreSQL backend for `hookly.db`
+- [ ] CLI: `hookly new my-project`
+
+---
+
+## Philosophy
+
+Hookly isn't trying to replace FastAPI or Django — it's for the moment
+before that, when you just need something working *now*: a table, an
+endpoint, a contact list. Grow out of it, swap in the big tools later.
+
+---
+
+## License
+
+MIT

hookly-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+hookly/__init__.py,sha256=WF4DIh-JaLs90kriePQPkz8EKLkESqXgKZKtOU4SO4k,543
+hookly/api/__init__.py,sha256=QZO1J9kqpYidnj1MiYtILAUWGmKLDwW2TpvO9gJcczI,41
+hookly/api/core.py,sha256=7yoEmd9cw8IWPVX7G8dH8CLB0EJGQoxn2a0Ohaz8f0k,2495
+hookly/crm/__init__.py,sha256=hnpSDw9g4TvtFD9Gu9RTubzWzbLbUwvJAGZ3TuFjQZU,61
+hookly/crm/core.py,sha256=nDgissnNKZOVtdpJTBk_qhFlP2B_c-5_wiWAKa8GQGA,2394
+hookly/db/__init__.py,sha256=-OGjZDIpfVw1A8HsIQ-ls_RcKmTprul2zM_aBh98M3g,53
+hookly/db/sqlite.py,sha256=PwFCmViqSZUJUpwHZ6eQhWCR6UHb0tnUT6a455qZXIU,2609
+hookly-0.1.0.dist-info/METADATA,sha256=hp1whSKCJR6XmfDfnezbnb5Fd_QnbkUC1-P9QI8aYFc,3336
+hookly-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+hookly-0.1.0.dist-info/RECORD,,

hookly-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any