hookly 0.1.0__tar.gz → 0.1.5__tar.gz

hookly-0.1.5/PKG-INFO

@@ -0,0 +1,305 @@
+Metadata-Version: 2.5
+Name: hookly
+Version: 0.1.5
+Summary: Batteries-included backend toolkit for Python — API, DB and CRM, ready to call.
+Project-URL: Homepage, https://github.com/Xar1ee/hookly
+Project-URL: Repository, https://github.com/Xar1ee/hookly
+Project-URL: Issues, https://github.com/Xar1ee/hookly/issues
+Author-email: Safaraliyev Xushnud <xushnudbackend@gmail.com>
+License: MIT
+Keywords: api,backend,crm,framework,sqlite,toolkit,webhook
+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
+Requires-Dist: colorama>=0.4
+Requires-Dist: python-dotenv>=1.0
+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 and a CRM by hand for every new project — 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)
+![Dependencies](https://img.shields.io/badge/dependencies-2-lightgrey)
+
+Created by **Safaraliyev Xushnud**
+
+---
+
+## Contents
+
+- [Why Hookly exists](#why-hookly-exists)
+- [Install](#install)
+- [60-second quickstart](#60-second-quickstart)
+- [hookly.db — database without the ceremony](#hooklydb--database-without-the-ceremony)
+- [hookly.crm — contacts and leads, ready to go](#hooklycrm--contacts-and-leads-ready-to-go)
+- [hookly.api — a tiny JSON router](#hooklyapi--a-tiny-json-router)
+- [Configuration via .env](#configuration-via-env)
+- [Full example: a working mini-CRM API](#full-example-a-working-mini-crm-api)
+- [FAQ](#faq)
+- [Roadmap](#roadmap)
+- [Source & links](#source--links)
+
+---
+
+## Why Hookly exists
+
+Every backend project — a website, a Telegram bot's admin panel, an internal tool — ends up needing the same three things:
+
+1. **Somewhere to store data** (usually a quick SQLite file, at least at first)
+2. **Something to track contacts, leads or requests** (a mini-CRM)
+3. **A way to expose it all as an API** (so a frontend, a bot, or Postman can talk to it)
+
+Normally you rebuild all three from scratch, every single time. **Hookly ships all three as ready-made modules that already work together.** You don't write a database layer — you call `Database`. You don't write a contacts table — you call `CRM`. You don't wire up routes by hand — you decorate a function and call `API`.
+
+> Hookly isn't trying to replace Django or FastAPI. It's for the moment *before* that — when you just need something working **right now**.
+
+---
+
+## Install
+
+```bash
+pip install hookly
+```
+
+That's it — `pip` also pulls in the two small libraries Hookly relies on:
+
+| Package | What it's used for |
+|---|---|
+| [`python-dotenv`](https://pypi.org/project/python-dotenv/) | Lets you configure Hookly with a `.env` file instead of hardcoding values |
+| [`colorama`](https://pypi.org/project/colorama/) | Makes Hookly's console output colored — including on Windows |
+
+Nothing else. No Django, no ORM, no config files you have to write before your first line of code runs.
+
+For local development (running the test suite):
+
+```bash
+pip install -e ".[dev]"
+```
+
+---
+
+## 60-second quickstart
+
+Create a file called `main.py`:
+
+```python
+from hookly import Database, CRM, API
+
+db = Database("app.db")     # SQLite file — created automatically
+crm = CRM(db)                # contacts table — created automatically
+api = API("my-service")      # your API, named however you like
+
+@api.get("/contacts")
+def list_contacts():
+    return crm.list_contacts()
+
+@api.post("/contacts")
+def new_contact():
+    contact = crm.add_contact("Ali", phone="+998901234567")
+    return {"id": contact.id, "name": contact.name}
+
+api.run(port=8000)
+```
+
+Run it:
+
+```bash
+python main.py
+```
+
+Open `http://127.0.0.1:8000/contacts` in your browser — you'll see an empty list `[]`. Send a `POST` request to the same address (Postman, curl, or your browser's console) and refresh — your contact is there, saved in SQLite, served over HTTP. **That's the whole stack, in fifteen lines.**
+
+---
+
+## `hookly.db` — database without the ceremony
+
+No models to declare, no migration files, no `Base.metadata.create_all()` — describe a table once as a plain dictionary, then insert and fetch with normal Python calls.
+
+```python
+from hookly import Database
+
+db = Database("app.db")
+
+db.create_table("users", {
+    "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+    "name": "TEXT NOT NULL",
+    "email": "TEXT",
+})
+
+user_id = db.insert("users", name="Ali", email="ali@example.com")
+
+all_users = db.fetchall("SELECT * FROM users")
+one_user = db.fetchone("SELECT * FROM users WHERE id = ?", (user_id,))
+
+db.update("users", "id = ?", (user_id,), name="Ali Karimov")
+db.delete("users", "id = ?", (user_id,))
+
+db.close()
+```
+
+Or use it as a context manager so it closes itself:
+
+```python
+with Database("app.db") as db:
+    db.create_table("logs", {"id": "INTEGER PRIMARY KEY", "message": "TEXT"})
+    db.insert("logs", message="app started")
+```
+
+---
+
+## `hookly.crm` — contacts and leads, ready to go
+
+Every project eventually needs *some* place to track "people who reached out." Instead of building that table again, use `CRM` — it's a `Database` with a contacts schema and status tracking built in.
+
+```python
+from hookly import CRM
+
+crm = CRM()  # uses its own SQLite file if you don't pass a Database
+
+contact = crm.add_contact("Ali", phone="+998901234567", email="ali@example.com")
+# Contact(id=1, name='Ali', phone='+998901234567', email='ali@example.com', status='new', created_at='...')
+
+crm.update_status(contact.id, "in_progress")
+
+leads_in_progress = crm.list_contacts(status="in_progress")
+
+crm.delete_contact(contact.id)
+```
+
+Statuses move through `new → in_progress → closed` — enough structure to build a real lead pipeline, simple enough to not fight you.
+
+---
+
+## `hookly.api` — a tiny JSON router
+
+A decorator-based HTTP router, built entirely on Python's standard library — **zero extra dependencies for the API layer itself.** Perfect for prototypes, internal tools, and services that don't need the full weight of a framework yet.
+
+```python
+from hookly import API
+
+api = API("my-service")
+
+@api.get("/ping")
+def ping():
+    return {"status": "ok"}
+
+@api.get("/users/count")
+def user_count():
+    return {"count": 42}
+
+api.run(host="0.0.0.0", port=8000)
+```
+
+Every handler just returns a Python `dict` or `list` — Hookly serializes it to JSON automatically. If a handler raises an exception, Hookly catches it and returns a clean `500` JSON error instead of crashing your whole server.
+
+> Outgrowing it? That's expected — swap `hookly.api` for FastAPI or Django REST Framework later. Hookly's job was to get you moving on day one, not to be the framework you ship to millions of users.
+
+---
+
+## Configuration via `.env`
+
+Instead of hardcoding paths and ports, drop a `.env` file next to your script:
+
+```
+HOOKLY_DB_PATH=production.db
+HOOKLY_HOST=0.0.0.0
+HOOKLY_PORT=9000
+```
+
+```python
+from hookly import Database, API
+
+db = Database()      # reads HOOKLY_DB_PATH automatically
+api = API("service")
+api.run()             # reads HOOKLY_HOST / HOOKLY_PORT automatically
+```
+
+No `.env` file? Hookly falls back to sensible defaults (`hookly.db`, `127.0.0.1:8000`) — configuration is optional, not required.
+
+---
+
+## Full example: a working mini-CRM API
+
+```python
+from hookly import Database, CRM, API
+
+db = Database("crm.db")
+crm = CRM(db)
+api = API("mini-crm")
+
+@api.get("/contacts")
+def all_contacts():
+    return crm.list_contacts()
+
+@api.get("/contacts/new")
+def new_leads():
+    return crm.list_contacts(status="new")
+
+@api.post("/contacts")
+def add_lead():
+    contact = crm.add_contact("New Lead", phone="+998900000000")
+    return {"id": contact.id, "status": contact.status}
+
+if __name__ == "__main__":
+    api.run(port=8000)
+```
+
+Five imports, three routes, one file — a running CRM backend with persistent storage.
+
+---
+
+## FAQ
+
+**Does Hookly support PostgreSQL / MySQL?**
+Not yet — `hookly.db` is SQLite-only for now. See [Roadmap](#roadmap).
+
+**Can I use Hookly in production?**
+For internal tools and small services, sure. For anything public-facing at scale, use Hookly to prototype fast, then migrate the API layer to FastAPI/Django once you know what you're building — the CRM and DB modules can usually stay as-is.
+
+**Why does the API return a `dict`, not a `Response` object?**
+Because 90% of the time that's all you need. Simplicity is the point — if you need response headers, status code control, or streaming, it's time to graduate to a full framework.
+
+**Is `.env` required?**
+No — it's entirely optional. Hookly works with zero configuration out of the box.
+
+---
+
+## Roadmap
+
+- [ ] `hookly.auth` — token-based authentication, ready to drop into `API`
+- [ ] `hookly.webhook` — send and receive webhooks natively (it's in the name!)
+- [ ] Async support (`AsyncDatabase`, `AsyncAPI`)
+- [ ] PostgreSQL backend for `hookly.db`
+- [ ] Pagination helpers for large result sets
+- [ ] CLI: `hookly new my-project` to scaffold a starter project
+- [ ] `hookly.telegram` — a thin bridge for wiring a Telegram bot to the same CRM
+
+Have an idea? Open an issue on GitHub — see below.
+
+---
+
+## Source & links
+
+- **PyPI:** [pypi.org/project/hookly](https://pypi.org/project/hookly/)
+- **GitHub:** [github.com/Xar1ee/hookly](https://github.com/Xar1ee/hookly)
+- **Issues / feature requests:** [github.com/Xar1ee/hookly/issues](https://github.com/Xar1ee/hookly/issues)
+
+Hookly is free and open for everyone. Fork it, break it, improve it — and if something's confusing, open an issue rather than suffering in silence.
+
+## License
+
+MIT — do whatever you want with it, just keep the license notice.

hookly-0.1.5/README.md

@@ -0,0 +1,278 @@
+# ⚡ Hookly
+
+**Batteries-included backend toolkit for Python.**
+Stop wiring up an API, a database and a CRM by hand for every new project — 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)
+![Dependencies](https://img.shields.io/badge/dependencies-2-lightgrey)
+
+Created by **Safaraliyev Xushnud**
+
+---
+
+## Contents
+
+- [Why Hookly exists](#why-hookly-exists)
+- [Install](#install)
+- [60-second quickstart](#60-second-quickstart)
+- [hookly.db — database without the ceremony](#hooklydb--database-without-the-ceremony)
+- [hookly.crm — contacts and leads, ready to go](#hooklycrm--contacts-and-leads-ready-to-go)
+- [hookly.api — a tiny JSON router](#hooklyapi--a-tiny-json-router)
+- [Configuration via .env](#configuration-via-env)
+- [Full example: a working mini-CRM API](#full-example-a-working-mini-crm-api)
+- [FAQ](#faq)
+- [Roadmap](#roadmap)
+- [Source & links](#source--links)
+
+---
+
+## Why Hookly exists
+
+Every backend project — a website, a Telegram bot's admin panel, an internal tool — ends up needing the same three things:
+
+1. **Somewhere to store data** (usually a quick SQLite file, at least at first)
+2. **Something to track contacts, leads or requests** (a mini-CRM)
+3. **A way to expose it all as an API** (so a frontend, a bot, or Postman can talk to it)
+
+Normally you rebuild all three from scratch, every single time. **Hookly ships all three as ready-made modules that already work together.** You don't write a database layer — you call `Database`. You don't write a contacts table — you call `CRM`. You don't wire up routes by hand — you decorate a function and call `API`.
+
+> Hookly isn't trying to replace Django or FastAPI. It's for the moment *before* that — when you just need something working **right now**.
+
+---
+
+## Install
+
+```bash
+pip install hookly
+```
+
+That's it — `pip` also pulls in the two small libraries Hookly relies on:
+
+| Package | What it's used for |
+|---|---|
+| [`python-dotenv`](https://pypi.org/project/python-dotenv/) | Lets you configure Hookly with a `.env` file instead of hardcoding values |
+| [`colorama`](https://pypi.org/project/colorama/) | Makes Hookly's console output colored — including on Windows |
+
+Nothing else. No Django, no ORM, no config files you have to write before your first line of code runs.
+
+For local development (running the test suite):
+
+```bash
+pip install -e ".[dev]"
+```
+
+---
+
+## 60-second quickstart
+
+Create a file called `main.py`:
+
+```python
+from hookly import Database, CRM, API
+
+db = Database("app.db")     # SQLite file — created automatically
+crm = CRM(db)                # contacts table — created automatically
+api = API("my-service")      # your API, named however you like
+
+@api.get("/contacts")
+def list_contacts():
+    return crm.list_contacts()
+
+@api.post("/contacts")
+def new_contact():
+    contact = crm.add_contact("Ali", phone="+998901234567")
+    return {"id": contact.id, "name": contact.name}
+
+api.run(port=8000)
+```
+
+Run it:
+
+```bash
+python main.py
+```
+
+Open `http://127.0.0.1:8000/contacts` in your browser — you'll see an empty list `[]`. Send a `POST` request to the same address (Postman, curl, or your browser's console) and refresh — your contact is there, saved in SQLite, served over HTTP. **That's the whole stack, in fifteen lines.**
+
+---
+
+## `hookly.db` — database without the ceremony
+
+No models to declare, no migration files, no `Base.metadata.create_all()` — describe a table once as a plain dictionary, then insert and fetch with normal Python calls.
+
+```python
+from hookly import Database
+
+db = Database("app.db")
+
+db.create_table("users", {
+    "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+    "name": "TEXT NOT NULL",
+    "email": "TEXT",
+})
+
+user_id = db.insert("users", name="Ali", email="ali@example.com")
+
+all_users = db.fetchall("SELECT * FROM users")
+one_user = db.fetchone("SELECT * FROM users WHERE id = ?", (user_id,))
+
+db.update("users", "id = ?", (user_id,), name="Ali Karimov")
+db.delete("users", "id = ?", (user_id,))
+
+db.close()
+```
+
+Or use it as a context manager so it closes itself:
+
+```python
+with Database("app.db") as db:
+    db.create_table("logs", {"id": "INTEGER PRIMARY KEY", "message": "TEXT"})
+    db.insert("logs", message="app started")
+```
+
+---
+
+## `hookly.crm` — contacts and leads, ready to go
+
+Every project eventually needs *some* place to track "people who reached out." Instead of building that table again, use `CRM` — it's a `Database` with a contacts schema and status tracking built in.
+
+```python
+from hookly import CRM
+
+crm = CRM()  # uses its own SQLite file if you don't pass a Database
+
+contact = crm.add_contact("Ali", phone="+998901234567", email="ali@example.com")
+# Contact(id=1, name='Ali', phone='+998901234567', email='ali@example.com', status='new', created_at='...')
+
+crm.update_status(contact.id, "in_progress")
+
+leads_in_progress = crm.list_contacts(status="in_progress")
+
+crm.delete_contact(contact.id)
+```
+
+Statuses move through `new → in_progress → closed` — enough structure to build a real lead pipeline, simple enough to not fight you.
+
+---
+
+## `hookly.api` — a tiny JSON router
+
+A decorator-based HTTP router, built entirely on Python's standard library — **zero extra dependencies for the API layer itself.** Perfect for prototypes, internal tools, and services that don't need the full weight of a framework yet.
+
+```python
+from hookly import API
+
+api = API("my-service")
+
+@api.get("/ping")
+def ping():
+    return {"status": "ok"}
+
+@api.get("/users/count")
+def user_count():
+    return {"count": 42}
+
+api.run(host="0.0.0.0", port=8000)
+```
+
+Every handler just returns a Python `dict` or `list` — Hookly serializes it to JSON automatically. If a handler raises an exception, Hookly catches it and returns a clean `500` JSON error instead of crashing your whole server.
+
+> Outgrowing it? That's expected — swap `hookly.api` for FastAPI or Django REST Framework later. Hookly's job was to get you moving on day one, not to be the framework you ship to millions of users.
+
+---
+
+## Configuration via `.env`
+
+Instead of hardcoding paths and ports, drop a `.env` file next to your script:
+
+```
+HOOKLY_DB_PATH=production.db
+HOOKLY_HOST=0.0.0.0
+HOOKLY_PORT=9000
+```
+
+```python
+from hookly import Database, API
+
+db = Database()      # reads HOOKLY_DB_PATH automatically
+api = API("service")
+api.run()             # reads HOOKLY_HOST / HOOKLY_PORT automatically
+```
+
+No `.env` file? Hookly falls back to sensible defaults (`hookly.db`, `127.0.0.1:8000`) — configuration is optional, not required.
+
+---
+
+## Full example: a working mini-CRM API
+
+```python
+from hookly import Database, CRM, API
+
+db = Database("crm.db")
+crm = CRM(db)
+api = API("mini-crm")
+
+@api.get("/contacts")
+def all_contacts():
+    return crm.list_contacts()
+
+@api.get("/contacts/new")
+def new_leads():
+    return crm.list_contacts(status="new")
+
+@api.post("/contacts")
+def add_lead():
+    contact = crm.add_contact("New Lead", phone="+998900000000")
+    return {"id": contact.id, "status": contact.status}
+
+if __name__ == "__main__":
+    api.run(port=8000)
+```
+
+Five imports, three routes, one file — a running CRM backend with persistent storage.
+
+---
+
+## FAQ
+
+**Does Hookly support PostgreSQL / MySQL?**
+Not yet — `hookly.db` is SQLite-only for now. See [Roadmap](#roadmap).
+
+**Can I use Hookly in production?**
+For internal tools and small services, sure. For anything public-facing at scale, use Hookly to prototype fast, then migrate the API layer to FastAPI/Django once you know what you're building — the CRM and DB modules can usually stay as-is.
+
+**Why does the API return a `dict`, not a `Response` object?**
+Because 90% of the time that's all you need. Simplicity is the point — if you need response headers, status code control, or streaming, it's time to graduate to a full framework.
+
+**Is `.env` required?**
+No — it's entirely optional. Hookly works with zero configuration out of the box.
+
+---
+
+## Roadmap
+
+- [ ] `hookly.auth` — token-based authentication, ready to drop into `API`
+- [ ] `hookly.webhook` — send and receive webhooks natively (it's in the name!)
+- [ ] Async support (`AsyncDatabase`, `AsyncAPI`)
+- [ ] PostgreSQL backend for `hookly.db`
+- [ ] Pagination helpers for large result sets
+- [ ] CLI: `hookly new my-project` to scaffold a starter project
+- [ ] `hookly.telegram` — a thin bridge for wiring a Telegram bot to the same CRM
+
+Have an idea? Open an issue on GitHub — see below.
+
+---
+
+## Source & links
+
+- **PyPI:** [pypi.org/project/hookly](https://pypi.org/project/hookly/)
+- **GitHub:** [github.com/Xar1ee/hookly](https://github.com/Xar1ee/hookly)
+- **Issues / feature requests:** [github.com/Xar1ee/hookly/issues](https://github.com/Xar1ee/hookly/issues)
+
+Hookly is free and open for everyone. Fork it, break it, improve it — and if something's confusing, open an issue rather than suffering in silence.
+
+## License
+
+MIT — do whatever you want with it, just keep the license notice.

hookly-0.1.5/hookly/__init__.py

@@ -0,0 +1,12 @@
+"""
+Hookly — batteries-included backend toolkit for Python.
+
+    from hookly import Database, CRM, API
+"""
+
+from .db import Database
+from .crm import CRM
+from .api import API
+
+__version__ = "0.1.1"
+__all__ = ["Database", "CRM", "API", "__version__"]

{hookly-0.1.0 → hookly-0.1.5}/hookly/api/core.py

@@ -1,21 +1,24 @@
 """
-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.
+hookly.api — a tiny decorator-based JSON API router, pure stdlib for the
+server itself, with a colorama-powered console banner (works on Windows
+too, unlike raw ANSI codes) and .env-based defaults via python-dotenv.
 """
 
 from __future__ import annotations
 
 import json
+import os
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from typing import Callable
 
+from colorama import Fore, Style, init as colorama_init
+from dotenv import load_dotenv
+
+load_dotenv()
+colorama_init(autoreset=True)
 
-class API:
-    """Call it, don't build it: a minimal HTTP router."""
 
+class API:
     def __init__(self, name: str = "hookly-api") -> None:
         self.name = name
         self._routes: dict[tuple[str, str], Callable] = {}
@@ -24,7 +27,6 @@ class API:
         def decorator(func: Callable) -> Callable:
             self._routes[(method.upper(), path)] = func
             return func
-
         return decorator
 
     def get(self, path: str) -> Callable:
@@ -33,7 +35,9 @@ class API:
     def post(self, path: str) -> Callable:
         return self.route(path, "POST")
 
-    def run(self, host: str = "127.0.0.1", port: int = 8000) -> None:
+    def run(self, host: str | None = None, port: int | None = None) -> None:
+        host = host or os.getenv("HOOKLY_HOST", "127.0.0.1")
+        port = port or int(os.getenv("HOOKLY_PORT", "8000"))
         routes = self._routes
 
         class Handler(BaseHTTPRequestHandler):
@@ -49,7 +53,7 @@ class API:
                     result = handler()
                     body = json.dumps(result).encode()
                     status = 200
-                except Exception as exc:  # noqa: BLE001 - surface errors as JSON
+                except Exception as exc:
                     body = json.dumps({"error": str(exc)}).encode()
                     status = 500
                 self.send_response(status)
@@ -57,14 +61,15 @@ class API:
                 self.end_headers()
                 self.wfile.write(body)
 
-            def do_GET(self) -> None:  # noqa: N802 - stdlib naming
+            def do_GET(self) -> None:
                 self._handle("GET")
 
-            def do_POST(self) -> None:  # noqa: N802 - stdlib naming
+            def do_POST(self) -> None:
                 self._handle("POST")
 
-            def log_message(self, format: str, *args) -> None:  # noqa: A002
-                pass  # keep the console quiet
+            def log_message(self, format: str, *args) -> None:
+                pass
 
-        print(f"⚡ {self.name} running at http://{host}:{port}")
+        print(f"{Fore.CYAN}⚡ {Style.BRIGHT}{self.name}{Style.RESET_ALL}{Fore.CYAN} "
+              f"running at {Fore.YELLOW}http://{host}:{port}{Style.RESET_ALL}")
         HTTPServer((host, port), Handler).serve_forever()

{hookly-0.1.0 → hookly-0.1.5}/hookly/crm/core.py

@@ -1,8 +1,5 @@
 """
 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
@@ -20,13 +17,11 @@ class Contact:
     name: str
     phone: str = ""
     email: str = ""
-    status: str = "new"  # new -> in_progress -> closed
+    status: str = "new"
     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:

{hookly-0.1.0 → hookly-0.1.5}/hookly/db/sqlite.py

@@ -3,24 +3,30 @@ 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.
+
+The default database path can be set via a HOOKLY_DB_PATH variable in a
+.env file, thanks to python-dotenv — handy for keeping paths out of code.
 """
 
 from __future__ import annotations
 
+import os
 import sqlite3
 from typing import Any, Iterable, Optional
 
+from dotenv import load_dotenv
+
+load_dotenv()
+
 
 class Database:
     """Thin, friendly wrapper around sqlite3."""
 
-    def __init__(self, path: str = "hookly.db") -> None:
-        self.path = path
+    def __init__(self, path: str | None = None) -> None:
+        self.path = path or os.getenv("HOOKLY_DB_PATH", "hookly.db")
         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()
@@ -35,15 +41,11 @@ class Database:
         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(

{hookly-0.1.0 → hookly-0.1.5}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hookly"
-version = "0.1.0"
+version = "0.1.5"
 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"]
+authors = [{ name = "Safaraliyev Xushnud", email = "xushnudbackend@gmail.com" }]
+keywords = ["backend", "api", "crm", "sqlite", "toolkit", "framework", "webhook"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
@@ -23,15 +23,18 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Internet :: WWW/HTTP :: WSGI :: Application",
 ]
-dependencies = []
+dependencies = [
+    "python-dotenv>=1.0",
+    "colorama>=0.4",
+]
 
 [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"
+Homepage = "https://github.com/Xar1ee/hookly"
+Repository = "https://github.com/Xar1ee/hookly"
+Issues = "https://github.com/Xar1ee/hookly/issues"
 
 [tool.hatch.build.targets.wheel]
 packages = ["hookly"]

hookly-0.1.0/PKG-INFO

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

@@ -1,110 +0,0 @@
-# ⚡ 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

@@ -1,25 +0,0 @@
-"""
-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__"]