pybasedb-json 0.2.0__py3-none-any.whl

pybase/__init__.py

@@ -0,0 +1,13 @@
+from .collections import Collection
+from .database import Database
+from .exceptions import CollectionError, DatabaseError, PybaseError
+from .query import Query
+
+__all__ = [
+    "Database",
+    "Collection",
+    "Query",
+    "PybaseError",
+    "DatabaseError",
+    "CollectionError",
+]

pybase/collections.py

@@ -0,0 +1,133 @@
+import json
+import threading
+from pathlib import Path
+
+from .exceptions import CollectionError
+
+
+class Collection:
+    def __init__(self, file_path: str | Path) -> None:
+        self.file_path = Path(file_path)
+        self._lock = threading.Lock()
+
+    def __str__(self) -> str:
+        return str(self.file_path)
+
+    def __len__(self) -> int:
+        return len(self._load())
+
+    def __iter__(self):
+        return iter(self._load())
+
+    def __getitem__(self, index: int | slice) -> dict | list[dict]:
+        return self._load()[index]
+
+    # -- io interno (sem lock) --
+
+    def _load_nolock(self) -> list:
+        if not self.file_path.exists():
+            return []
+        try:
+            with open(self.file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except json.JSONDecodeError:
+            raise CollectionError(
+                f"arquivo corrompido: {self.file_path}"
+            )
+        if not isinstance(data, list):
+            raise CollectionError(
+                f"esperava uma lista, recebeu {type(data).__name__}"
+                f": {self.file_path}"
+            )
+        return data
+
+    def _save_nolock(self, data: list) -> None:
+        with open(self.file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4)
+
+    def _load(self) -> list:
+        with self._lock:
+            return self._load_nolock()
+
+    def _save(self, data: list) -> None:
+        with self._lock:
+            self._save_nolock(data)
+
+    # -- leitura (thread-safe via _load) --
+
+    def all(self) -> list[dict]:
+        return list(self._load())
+
+    def count(self, **match) -> int:
+        if not match:
+            return len(self._load())
+        docs = self._load()
+        return sum(
+            1
+            for doc in docs
+            if all(doc.get(k) == v for k, v in match.items())
+        )
+
+    def get(self, doc_id: str | int, key: str = "id") -> dict | None:
+        for doc in self._load():
+            if doc.get(key) == doc_id:
+                return doc
+        return None
+
+    # -- escrita (atomica via lock unico) --
+
+    def add(self, data: dict) -> dict:
+        doc = dict(data)
+        with self._lock:
+            docs = self._load_nolock()
+            docs.append(doc)
+            self._save_nolock(docs)
+        return doc
+
+    def add_many(self, items: list[dict]) -> list[dict]:
+        if not isinstance(items, list):
+            raise TypeError("add_many espera uma lista de dicionarios")
+        with self._lock:
+            docs = self._load_nolock()
+            added = [dict(item) for item in items]
+            docs.extend(added)
+            self._save_nolock(docs)
+        return added
+
+    def actualize(self, data: dict, **match) -> int:
+        if not match:
+            raise CollectionError(
+                "informe um campo de busca, "
+                "ex: actualize({'age': 20}, name='marcos')"
+            )
+        with self._lock:
+            docs = self._load_nolock()
+            updated = 0
+            for doc in docs:
+                if all(doc.get(k) == v for k, v in match.items()):
+                    doc.update(data)
+                    updated += 1
+            if updated:
+                self._save_nolock(docs)
+        return updated
+
+    def rem(self, **match) -> int:
+        if not match:
+            raise CollectionError(
+                "informe um campo de busca, ex: rem(name='marcos')"
+            )
+        with self._lock:
+            docs = self._load_nolock()
+            kept = [
+                doc
+                for doc in docs
+                if not all(doc.get(k) == v for k, v in match.items())
+            ]
+            removed = len(docs) - len(kept)
+            if removed:
+                self._save_nolock(kept)
+        return removed
+
+    def drop(self) -> None:
+        with self._lock:
+            self._save_nolock([])

pybase/database.py

@@ -0,0 +1,72 @@
+import json
+import shutil
+from pathlib import Path
+
+from .collections import Collection
+from .exceptions import DatabaseError
+from .utils import Utils
+
+
+class Database:
+    def __init__(self, local: str | Path, name: str, password: str) -> None:
+        self.local = Path(local)
+        self.name = name
+        self.password = str(Utils.encode(password))
+
+        self.path_dir = self.local / self.name
+        self.path_dir.mkdir(parents=True, exist_ok=True)
+        self.path_conf = self.path_dir / f"{name}_conf.json"
+        if not self.path_conf.exists():
+            self.path_conf.write_text(
+                json.dumps({"password": self.password}, indent=4)
+            )
+
+    def __str__(self) -> str:
+        return str(self.path_dir)
+
+    def _verify_password(self, password: str) -> dict:
+        try:
+            with open(self.path_conf, "r", encoding="utf-8") as f:
+                dados = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            raise DatabaseError(
+                f"database '{self.name}' corrompido ou inexistente"
+            )
+        if str(Utils.encode(password)) != dados.get("password"):
+            raise DatabaseError("senha incorreta")
+        return dados
+
+    def open(self, password: str) -> "Database":
+        self._verify_password(password)
+        return self
+
+    def _table_paths(self) -> list[Path]:
+        return list(self.path_dir.glob("*_table.json"))
+
+    def info(self) -> dict:
+        tables = self._table_paths()
+        return {
+            "name": self.name,
+            "path": str(self.path_dir),
+            "collections": [
+                p.stem.removesuffix("_table") for p in tables
+            ],
+            "size": sum(
+                p.stat().st_size for p in tables if p.is_file()
+            ),
+        }
+
+    def collections(self) -> list[str]:
+        return [p.stem.removesuffix("_table") for p in self._table_paths()]
+
+    def collection(self, name: str) -> Collection:
+        path = self.path_dir / f"{name}_table.json"
+        if not path.exists():
+            with open(path, "w", encoding="utf-8") as f:
+                json.dump([], f, indent=4)
+        return Collection(path)
+
+    def drop(self, password: str) -> None:
+        self._verify_password(password)
+        if self.path_dir.exists():
+            shutil.rmtree(self.path_dir)

pybase/exceptions.py

@@ -0,0 +1,14 @@
+class PybaseError(Exception):
+    pass
+
+
+class DatabaseError(PybaseError):
+    pass
+
+
+class CollectionError(PybaseError):
+    pass
+
+
+class DocumentNotFoundError(CollectionError):
+    pass

pybase/query.py

@@ -0,0 +1,73 @@
+from .collections import Collection
+
+
+class Query:
+    def __init__(self, collection: Collection) -> None:
+        self._collection = collection
+        self._limit: int | None = None
+        self._offset: int | None = None
+        self._sort_key: str | None = None
+        self._sort_reverse: bool = False
+
+    def limit(self, n: int) -> "Query":
+        self._limit = n
+        return self
+
+    def offset(self, n: int) -> "Query":
+        self._offset = n
+        return self
+
+    def sort(self, key: str, reverse: bool = False) -> "Query":
+        self._sort_key = key
+        self._sort_reverse = reverse
+        return self
+
+    def _apply(self, docs: list[dict]) -> list[dict]:
+        if self._sort_key:
+            docs = sorted(
+                docs,
+                key=lambda d: d.get(self._sort_key, 0),
+                reverse=self._sort_reverse,
+            )
+        if self._offset is not None:
+            docs = docs[self._offset :]
+        if self._limit is not None:
+            docs = docs[: self._limit]
+        return docs
+
+    def _build(self, **match) -> list[dict]:
+        docs = self._collection.all()
+        if match:
+            docs = [
+                doc
+                for doc in docs
+                if all(doc.get(k) == v for k, v in match.items())
+            ]
+        return self._apply(docs)
+
+    def _reset(self) -> None:
+        self._limit = None
+        self._offset = None
+        self._sort_key = None
+        self._sort_reverse = False
+
+    def find(self, **match) -> list[dict]:
+        result = self._build(**match)
+        self._reset()
+        return result
+
+    def find_one(self, **match) -> dict | None:
+        docs = self._collection.all()
+        result = None
+        if not match:
+            result = docs[0] if docs else None
+        else:
+            for doc in docs:
+                if all(doc.get(k) == v for k, v in match.items()):
+                    result = doc
+                    break
+        self._reset()
+        return result
+
+    def exists(self, **match) -> bool:
+        return self.find_one(**match) is not None

pybase/utils.py

@@ -0,0 +1,11 @@
+from hashlib import sha256
+
+
+class Utils:
+
+    @staticmethod
+    def encode(text: str) -> str:
+        return sha256(text.encode()).hexdigest()
+
+
+Utly = Utils

pybasedb_json-0.2.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: pybasedb-json
+Version: 0.2.0
+Summary: Banco de dados local com JSON — zero dependencias, 100% stdlib, thread-safe
+Author-email: Marcos Gomes <marcosgabrielgomes110@gmail.com>
+Maintainer-email: Marcos Gomes <marcosgabrielgomes110@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marcosgabrielgomes110-collab/Pybase
+Project-URL: Documentation, https://github.com/marcosgabrielgomes110-collab/Pybase/tree/main/docs
+Project-URL: Repository, https://github.com/marcosgabrielgomes110-collab/Pybase
+Keywords: database,json,local,embedded,nosql,thread-safe
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="site/assets/logo/logo.png" width="120" alt="Pybase logo">
+</p>
+
+# Pybase
+
+Base para criacao de bancos de dados locais com JSON. Zero dependencias, 100% stdlib.
+Operacoes de escrita atomicas, thread-safe.
+
+## Instalacao
+
+```bash
+pip install pybasedb-json
+```
+
+## Uso
+
+```python
+from pybase import Database, Query
+
+db = Database("./data", "mydb", "minha-senha").open("minha-senha")
+
+users = db.collection("users")
+
+users.add({"id": "a1", "name": "marcos", "age": 25})
+users.add_many([
+    {"id": "a2", "name": "ana",    "age": 30},
+    {"id": "a3", "name": "marcos", "age": 40},
+])
+
+print(len(users))                    # 3
+print(users.count(name="marcos"))    # 2
+
+for doc in users:
+    print(doc["name"])               # marcos, ana, marcos
+
+doc = users.get("a1")                # por id
+print(doc)                           # {"id": "a1", "name": "marcos", "age": 25}
+
+q = Query(users)
+print(q.find(name="marcos"))                       # [doc_a1, doc_a3]
+print(q.sort("age", reverse=True).limit(1).find()) # [doc_a3]
+print(q.find_one(name="ana"))                      # {"id": "a2", ...}
+print(q.exists(name="joao"))                       # False
+
+users.actualize({"age": 26}, name="marcos")
+users.rem(id="a3")
+
+users.drop()    # limpa colecao
+# db.drop("minha-senha")  # deleta banco inteiro
+```
+
+## Estrutura
+
+```
+Pybase/
+  pybase/
+    __init__.py       # exports: Database, Collection, Query, PybaseError, ...
+    database.py       # Database: gerencia diretorio de tabelas JSON
+    collections.py    # Collection: CRUD atomico com lock por colecao
+    query.py          # Query: find/find_one/exists + sort/limit/offset
+    exceptions.py     # PybaseError > DatabaseError, CollectionError
+    utils.py          # Utils: sha256 encode
+  pyproject.toml
+```
+
+## Documentacao
+
+Veja [docs/](docs/index.md) com referencia completa de cada metodo.

pybasedb_json-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pybase/__init__.py,sha256=JDIhb8bxyo8Y77xPOgDKtYey5-TxLwhPY1pEPxXrxRo,285
+pybase/collections.py,sha256=yRsPuyLzyqKHSDi7aReuWEpBsNUzHKghoYoAzUo9dNc,3880
+pybase/database.py,sha256=Ew8-y_gRXl8eINY4VG-taQ8AO5SGEx5vwPKry6D4odA,2355
+pybase/exceptions.py,sha256=_asagITkRr0O6GY5uFZmanNqSulBBbjp_8JOAGG-rgo,188
+pybase/query.py,sha256=PCro0RWcdWpnu-_kX67gL7E0FuMK1oU6aHmQmeD3goA,2093
+pybase/utils.py,sha256=RNmaFYwECMlIp1ifAILAj_gtEeb7kLNvP1qs_RMBJZs,159
+pybasedb_json-0.2.0.dist-info/METADATA,sha256=KNpcWxzPEd26ut3GAAsUZzUt_i3VVGoazPi0zYuRMWM,2981
+pybasedb_json-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pybasedb_json-0.2.0.dist-info/top_level.txt,sha256=gYgKDnq77vSbZG-_hkku2uwMNI_t6Z7_WQq4dek8Al4,7
+pybasedb_json-0.2.0.dist-info/RECORD,,

pybasedb_json-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pybasedb_json-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pybase