hookly 0.1.0__tar.gz

hookly-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+*.db
+.pytest_cache/

hookly-0.1.0/.idea/.gitignore

@@ -0,0 +1,5 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/

hookly-0.1.0/.idea/hookly.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

hookly-0.1.0/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

hookly-0.1.0/.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.14 (hookly)" />
+  </component>
+</project>

hookly-0.1.0/.idea/workspace.xml

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="5347a489-26f6-4798-9b04-f4a3a2f63537" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 2,
+  &quot;fromUser&quot;: false
+}</component>
+  <component name="ProjectId" id="3JjBxqpJ9mZ3SuDLXtBXK1wfoWF" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "Python.main.executor": "Run",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.TerminalTabsStorage.copyFrom.TerminalArrangementManager.252": "true",
+    "RunOnceActivity.typescript.service.memoryLimit.init": "true",
+    "codeWithMe.voiceChat.enabledByDefault": "false",
+    "node.js.detected.package.eslint": "true",
+    "node.js.detected.package.tslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm"
+  }
+}]]></component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-python-sdk-b63d5a1f7c97-b61e75351b1f-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-261.22158.340" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="5347a489-26f6-4798-9b04-f4a3a2f63537" name="Changes" comment="" />
+      <created>1790164852777</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1790164852777</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+</project>

hookly-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,110 @@
+# ⚡ 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/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-0.1.0/hookly/api/__init__.py

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

hookly-0.1.0/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-0.1.0/hookly/crm/__init__.py

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

hookly-0.1.0/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-0.1.0/hookly/db/__init__.py

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

hookly-0.1.0/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/main.py

@@ -0,0 +1,15 @@
+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)

hookly-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hookly"
+version = "0.1.0"
+description = "Batteries-included backend toolkit for Python — API, DB and CRM, ready to call."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Your Name", email = "you@example.com" }]
+keywords = ["backend", "api", "crm", "sqlite", "toolkit", "framework"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Internet :: WWW/HTTP :: WSGI :: Application",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/hookly"
+Repository = "https://github.com/yourusername/hookly"
+Issues = "https://github.com/yourusername/hookly/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["hookly"]

hookly-0.1.0/tests/test_basic.py

@@ -0,0 +1,20 @@
+from hookly import Database, CRM
+
+
+def test_db_and_crm(tmp_path):
+    db_path = tmp_path / "test.db"
+    db = Database(str(db_path))
+    crm = CRM(db)
+
+    contact = crm.add_contact("Ali", phone="+998901234567", email="ali@example.com")
+    assert contact.id is not None
+
+    contacts = crm.list_contacts()
+    assert len(contacts) == 1
+    assert contacts[0]["name"] == "Ali"
+
+    crm.update_status(contact.id, "in_progress")
+    updated = crm.get_contact(contact.id)
+    assert updated["status"] == "in_progress"
+
+    db.close()