PyCyphORM 0.1.3__tar.gz → 26.5.25__tar.gz

pycyphorm-26.5.25/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: PyCyphORM
+Version: 26.5.25
+Summary: A simple in-memory encrypted ORM for SQLite3
+Author-email: Joao Martins <joaomartins@lts.pt>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0.0
+
+# PyCyphORM
+
+A simple in-memory encrypted ORM for SQLite3.
+
+The database lives in memory while in use and is persisted to disk as a gzipped,
+Fernet-encrypted blob. Keys are derived from a password and salt with PBKDF2-HMAC-SHA256.
+
+## Install
+
+```bash
+pip install PyCyphORM
+```
+
+## CLI
+
+Generate a `.pyorm` config (random salt + password) in the current directory:
+
+```bash
+pyorm --init 1
+```
+
+Decrypt an encrypted database file to `<file>.decoded.db`:
+
+```bash
+pyorm --decrypt path/to/db
+```
+
+## Library usage
+
+```python
+from pyorm import ORM, load_config
+
+cnf = load_config(".pyorm")
+
+orm = ORM("users.db", cnf["PASSWORD"], cnf["SALT"], {
+    "users": {
+        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+        "name": "TEXT NOT NULL",
+        "email": "TEXT NOT NULL",
+        "age": "INT NOT NULL",
+    }
+})
+
+users = orm.model("users")
+users.insert({"name": "Alice", "email": "alice@example.com", "age": 30})
+users.update({"name": "Alice"}, {"age": 31})
+print(users.find())
+print(users.first({"name": "Alice"}))
+users.delete({"name": "Alice"})
+
+orm.save()
+```
+
+`orm.save()` writes the encrypted snapshot back to disk. Without it, changes
+remain in memory only.
+
+## License
+
+MIT

pycyphorm-26.5.25/README.md

@@ -0,0 +1,59 @@
+# PyCyphORM
+
+A simple in-memory encrypted ORM for SQLite3.
+
+The database lives in memory while in use and is persisted to disk as a gzipped,
+Fernet-encrypted blob. Keys are derived from a password and salt with PBKDF2-HMAC-SHA256.
+
+## Install
+
+```bash
+pip install PyCyphORM
+```
+
+## CLI
+
+Generate a `.pyorm` config (random salt + password) in the current directory:
+
+```bash
+pyorm --init 1
+```
+
+Decrypt an encrypted database file to `<file>.decoded.db`:
+
+```bash
+pyorm --decrypt path/to/db
+```
+
+## Library usage
+
+```python
+from pyorm import ORM, load_config
+
+cnf = load_config(".pyorm")
+
+orm = ORM("users.db", cnf["PASSWORD"], cnf["SALT"], {
+    "users": {
+        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+        "name": "TEXT NOT NULL",
+        "email": "TEXT NOT NULL",
+        "age": "INT NOT NULL",
+    }
+})
+
+users = orm.model("users")
+users.insert({"name": "Alice", "email": "alice@example.com", "age": 30})
+users.update({"name": "Alice"}, {"age": 31})
+print(users.find())
+print(users.first({"name": "Alice"}))
+users.delete({"name": "Alice"})
+
+orm.save()
+```
+
+`orm.save()` writes the encrypted snapshot back to disk. Without it, changes
+remain in memory only.
+
+## License
+
+MIT

pycyphorm-26.5.25/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PyCyphORM"
+version = "26.5.25"
+description = "A simple in-memory encrypted ORM for SQLite3"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Joao Martins", email = "joaomartins@lts.pt" }]
+dependencies = [
+    "cryptography>=41.0.0",
+]
+
+[project.scripts]
+pyorm = "pyorm.cli:cli"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["pyorm*"]

pycyphorm-26.5.25/src/PyCyphORM.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: PyCyphORM
+Version: 26.5.25
+Summary: A simple in-memory encrypted ORM for SQLite3
+Author-email: Joao Martins <joaomartins@lts.pt>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0.0
+
+# PyCyphORM
+
+A simple in-memory encrypted ORM for SQLite3.
+
+The database lives in memory while in use and is persisted to disk as a gzipped,
+Fernet-encrypted blob. Keys are derived from a password and salt with PBKDF2-HMAC-SHA256.
+
+## Install
+
+```bash
+pip install PyCyphORM
+```
+
+## CLI
+
+Generate a `.pyorm` config (random salt + password) in the current directory:
+
+```bash
+pyorm --init 1
+```
+
+Decrypt an encrypted database file to `<file>.decoded.db`:
+
+```bash
+pyorm --decrypt path/to/db
+```
+
+## Library usage
+
+```python
+from pyorm import ORM, load_config
+
+cnf = load_config(".pyorm")
+
+orm = ORM("users.db", cnf["PASSWORD"], cnf["SALT"], {
+    "users": {
+        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+        "name": "TEXT NOT NULL",
+        "email": "TEXT NOT NULL",
+        "age": "INT NOT NULL",
+    }
+})
+
+users = orm.model("users")
+users.insert({"name": "Alice", "email": "alice@example.com", "age": 30})
+users.update({"name": "Alice"}, {"age": 31})
+print(users.find())
+print(users.first({"name": "Alice"}))
+users.delete({"name": "Alice"})
+
+orm.save()
+```
+
+`orm.save()` writes the encrypted snapshot back to disk. Without it, changes
+remain in memory only.
+
+## License
+
+MIT

pycyphorm-26.5.25/src/PyCyphORM.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/PyCyphORM.egg-info/PKG-INFO
+src/PyCyphORM.egg-info/SOURCES.txt
+src/PyCyphORM.egg-info/dependency_links.txt
+src/PyCyphORM.egg-info/entry_points.txt
+src/PyCyphORM.egg-info/requires.txt
+src/PyCyphORM.egg-info/top_level.txt
+src/pyorm/__init__.py
+src/pyorm/adapter.py
+src/pyorm/cli.py
+src/pyorm/orm.py
+tests/test_crud.py

pycyphorm-26.5.25/src/PyCyphORM.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyorm = pyorm.cli:cli

pycyphorm-26.5.25/src/PyCyphORM.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography>=41.0.0

pycyphorm-26.5.25/src/PyCyphORM.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyorm

pycyphorm-26.5.25/src/pyorm/__init__.py

@@ -0,0 +1,4 @@
+from .adapter import load_config
+from .orm import ORM
+
+__all__ = ["ORM", "load_config"]

{PyCyphORM-0.1.3/src/PyCyphORM/lib → pycyphorm-26.5.25/src/pyorm}/adapter.py

@@ -64,5 +64,3 @@ def save_cdb(con, filename, password, salt):
     b=encryption(b,password, salt)
     fp.write(b)
     fp.close()
-
-

{PyCyphORM-0.1.3/src/PyCyphORM → pycyphorm-26.5.25/src/pyorm}/cli.py

@@ -1,12 +1,11 @@
-#!/bin/env python3
+#!/usr/bin/env python3
 
 import argparse
-
-from os import urandom, path
-from base64 import b16encode
+import json
 import random
+from base64 import b16encode
+from os import urandom, path
 
-import json
 
 def random_password():
     password = ""
@@ -15,14 +14,15 @@ def random_password():
         password = password + random.choice(characters)
     return password
 
+
 parser = argparse.ArgumentParser(
-    prog = 'PyCyphORM',
-    description = 'A Minimalistic SQLite InMemory Encrypted ORM',
+    prog='pyorm',
+    description='A simple python orm',
 )
 
 parser.add_argument("-i", "--init", metavar="INIT", help="Initialize Salt and Password for Encrypted Database")
-parser.add_argument("-d", "--decrypt", metavar="FILEPATH", help="Descrypt SQLite Database")
-#parser.add_argument("output", metavar="DEST", default=".", help="Destination Folder")
+parser.add_argument("-d", "--decrypt", metavar="FILEPATH", help="Decrypt SQLite Database")
+
 
 def cli():
     args = vars(parser.parse_args())
@@ -35,11 +35,11 @@ def cli():
 
     elif args['decrypt']:
         if path.exists(path.abspath(args['decrypt'])):
-            
-            from .lib.adapter import decrypt_cdb, load_config
-            
+            from .adapter import decrypt_cdb, load_config
+
             cnf = load_config(".pyorm")
             decrypt_cdb(path.abspath(args['decrypt']), cnf["PASSWORD"], cnf["SALT"])
 
 
-if __name__ == "__main__": cli()
+if __name__ == "__main__":
+    cli()

{PyCyphORM-0.1.3/src/PyCyphORM/lib → pycyphorm-26.5.25/src/pyorm}/orm.py

@@ -45,8 +45,8 @@ class QueryBuilder:
                 count += 1
                 bulk.append("(%s)" % (",".join(values)))
             sql = "INSERT INTO %s (%s) VALUES %s" % (table, ",".join(columns), ",".join(bulk))
-        return sql   
-    
+        return sql
+
     @staticmethod
     def __create_table__(table, schema):
         definition = []
@@ -66,7 +66,7 @@ class QueryBuilder:
             sql += " WHERE %s" % self.__where__(where)
         return sql
 
-    
+
     def __select__(self, table, fields, where=None, orderby=None):
         sql = "SELECT %s FROM %s" % (",".join(fields), table)
         if isinstance(where, dict):
@@ -78,7 +78,7 @@ class QueryBuilder:
     def __delete__(self, table, where):
         sql = "DELETE FROM %s WHERE %s" % (table, self.__where__(where))
         return sql
-    
+
 class Model(QueryBuilder):
 
     def __init__(self, conn, table, schema):
@@ -92,7 +92,7 @@ class Model(QueryBuilder):
         cur.execute(sql)
         self.conn.commit()
         return cur.rowcount
-    
+
     def up(self):
         sql = self.__create_table__(self.table, self.schema)
         cur = self.conn.cursor()
@@ -115,7 +115,7 @@ class Model(QueryBuilder):
         return cur.rowcount
 
     def delete(self, where):
-        sql = self.__delete__(self.table, where)        
+        sql = self.__delete__(self.table, where)
         cur = self.conn.cursor()
         cur.execute(sql)
         self.conn.commit()
@@ -125,38 +125,29 @@ class Model(QueryBuilder):
         sql = self.__select__(self.table, ["*"], where)
         cur = self.conn.cursor()
         cur.execute(sql)
-        rows = cur.fetchall()
-        return rows
+        cols = [d[0] for d in cur.description]
+        return [dict(zip(cols, row)) for row in cur.fetchall()]
 
     def first(self, where):
         sql = self.__select__(self.table, ["*"], where)
         cur = self.conn.cursor()
         cur.execute(sql)
+        cols = [d[0] for d in cur.description]
         row = cur.fetchone()
-        return row
+        return dict(zip(cols, row)) if row else None
 
 class ORM:
-    
-    __models__ = {}
-    __instance__ = None
 
-    @staticmethod
-    def instance(filename, password, salt, schema):
-        if ORM.__instance__ == None:
-            ORM.__instance__ = ORM(filename, password, salt, schema)
-        return ORM.__instance__
+    __models__ = {}
 
     def __init__(self, filename, password, salt, schema):
 
         self.filename = filename
         self.password = password
         self.salt = salt
-        self.__instance__ = self
 
-        install = False
-        if os.path.exists(filename) == False:
-            install = True
-        
+        install = not os.path.exists(filename)
+
         self.conn = open_cdb(self.filename, self.password, self.salt)
 
         for table in schema:
@@ -170,6 +161,6 @@ class ORM:
         if name in self.__models__:
             return self.__models__[name]
         return None
-    
+
     def save(self):
         save_cdb(self.conn, self.filename, self.password, self.salt)

pycyphorm-26.5.25/tests/test_crud.py

@@ -0,0 +1,99 @@
+import json
+import os
+import subprocess
+import sys
+import tempfile
+
+from pyorm import ORM, load_config
+
+
+SCHEMA = {
+    "users": {
+        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+        "name": "TEXT NOT NULL",
+        "email": "TEXT NOT NULL",
+        "age": "INT NOT NULL",
+    }
+}
+
+
+def run_pyorm_init(workdir):
+    subprocess.run(
+        [sys.executable, "-m", "pyorm.cli", "--init", "1"],
+        cwd=workdir,
+        check=True,
+    )
+
+
+def test_init_creates_config_file():
+    with tempfile.TemporaryDirectory() as tmp:
+        run_pyorm_init(tmp)
+
+        config_path = os.path.join(tmp, ".pyorm")
+        assert os.path.exists(config_path), ".pyorm config file was not created"
+
+        with open(config_path) as f:
+            raw = json.load(f)
+        assert "SALT" in raw and "PASSWORD" in raw
+
+        cnf = load_config(config_path)
+        assert isinstance(cnf["SALT"], bytes) and len(cnf["SALT"]) == 16
+        assert isinstance(cnf["PASSWORD"], bytes) and len(cnf["PASSWORD"]) > 0
+
+
+def test_crud_roundtrip():
+    with tempfile.TemporaryDirectory() as tmp:
+        run_pyorm_init(tmp)
+        cnf = load_config(os.path.join(tmp, ".pyorm"))
+        db_path = os.path.join(tmp, "users.db")
+
+        orm = ORM(db_path, cnf["PASSWORD"], cnf["SALT"], SCHEMA)
+        users = orm.model("users")
+        assert users is not None
+
+        alice_id = users.insert({"name": "Alice", "email": "alice@example.com", "age": 30})
+        bob_id = users.insert({"name": "Bob", "email": "bob@example.com", "age": 42})
+        assert alice_id == 1 and bob_id == 2
+
+        rows = users.find()
+        assert len(rows) == 2
+
+        updated = users.update({"id": alice_id}, {"age": 31})
+        assert updated == 1
+
+        alice = users.first({"id": alice_id})
+        assert alice["name"] == "Alice" and alice["age"] == 31
+
+        deleted = users.delete({"id": bob_id})
+        assert deleted == 1
+        assert len(users.find()) == 1
+
+        orm.save()
+        assert os.path.exists(db_path), "encrypted db file was not written"
+
+
+def test_persistence_across_instances():
+    with tempfile.TemporaryDirectory() as tmp:
+        run_pyorm_init(tmp)
+        cnf = load_config(os.path.join(tmp, ".pyorm"))
+        db_path = os.path.join(tmp, "persist.db")
+
+        ORM.__models__ = {}
+        orm = ORM(db_path, cnf["PASSWORD"], cnf["SALT"], SCHEMA)
+        orm.model("users").insert({"name": "Carol", "email": "carol@example.com", "age": 25})
+        orm.save()
+
+        ORM.__models__ = {}
+        orm2 = ORM(db_path, cnf["PASSWORD"], cnf["SALT"], SCHEMA)
+        rows = orm2.model("users").find()
+        assert len(rows) == 1
+        assert rows[0]["name"] == "Carol"
+
+
+if __name__ == "__main__":
+    test_init_creates_config_file()
+    print("init test: ok")
+    test_crud_roundtrip()
+    print("crud test: ok")
+    test_persistence_across_instances()
+    print("persistence test: ok")

PyCyphORM-0.1.3/PKG-INFO

@@ -1,54 +0,0 @@
-Metadata-Version: 2.1
-Name: PyCyphORM
-Version: 0.1.3
-Summary: A Minimalistic SQLite InMemory Encrypted ORM
-Author: jafrmartins
-Author-email: j.afr.martins@outlook.pt
-Keywords: sqlite encrypted inmemory orm
-Description-Content-Type: text/markdown
-
-# PyCyphOrm
-
-A Minimalistic SQLite InMemory Encrypted ORM
-
-## Usage
-
-### Command Line Interface
-
-```sh
-usage: PyCyphORM [-h] [-i INIT] [-d FILEPATH]
-
-A Minimalistic SQLite InMemory Encrypted ORM
-
-options:
-  -h, --help            show this help message and exit
-  -i INIT, --init INIT  Initialize Salt and Password for
-                        Encrypted Database
-  -d FILEPATH, --decrypt FILEPATH
-                        Descrypt SQLite Database
-```
-
-### Example
-
-```python
-
-from PyCyphORM.lib import load_config, ORM
-
-cnf = load_config(".pyorm")
-orm = ORM.instance(".cache", cnf["PASSWORD"], cnf["SALT"], {
-    "Note": {
-        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
-        "title": "TEXT NOT NULL",
-        "description": "TEXT NOT NULL",
-        
-    }
-})
-
-orm.model("Note").insert({
-    "title": "Your Title #1",
-    "description": "Your Descriptioj #2",
-})
-
-orm.save()
-
-```

PyCyphORM-0.1.3/PyCyphORM.egg-info/PKG-INFO

@@ -1,54 +0,0 @@
-Metadata-Version: 2.1
-Name: PyCyphORM
-Version: 0.1.3
-Summary: A Minimalistic SQLite InMemory Encrypted ORM
-Author: jafrmartins
-Author-email: j.afr.martins@outlook.pt
-Keywords: sqlite encrypted inmemory orm
-Description-Content-Type: text/markdown
-
-# PyCyphOrm
-
-A Minimalistic SQLite InMemory Encrypted ORM
-
-## Usage
-
-### Command Line Interface
-
-```sh
-usage: PyCyphORM [-h] [-i INIT] [-d FILEPATH]
-
-A Minimalistic SQLite InMemory Encrypted ORM
-
-options:
-  -h, --help            show this help message and exit
-  -i INIT, --init INIT  Initialize Salt and Password for
-                        Encrypted Database
-  -d FILEPATH, --decrypt FILEPATH
-                        Descrypt SQLite Database
-```
-
-### Example
-
-```python
-
-from PyCyphORM.lib import load_config, ORM
-
-cnf = load_config(".pyorm")
-orm = ORM.instance(".cache", cnf["PASSWORD"], cnf["SALT"], {
-    "Note": {
-        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
-        "title": "TEXT NOT NULL",
-        "description": "TEXT NOT NULL",
-        
-    }
-})
-
-orm.model("Note").insert({
-    "title": "Your Title #1",
-    "description": "Your Descriptioj #2",
-})
-
-orm.save()
-
-```

PyCyphORM-0.1.3/PyCyphORM.egg-info/SOURCES.txt

@@ -1,12 +0,0 @@
-README.md
-setup.py
-PyCyphORM.egg-info/PKG-INFO
-PyCyphORM.egg-info/SOURCES.txt
-PyCyphORM.egg-info/dependency_links.txt
-PyCyphORM.egg-info/entry_points.txt
-PyCyphORM.egg-info/top_level.txt
-src/PyCyphORM/__init__.py
-src/PyCyphORM/cli.py
-src/PyCyphORM/lib/__init__.py
-src/PyCyphORM/lib/adapter.py
-src/PyCyphORM/lib/orm.py

PyCyphORM-0.1.3/PyCyphORM.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-pycyphorm = cli:cli

PyCyphORM-0.1.3/PyCyphORM.egg-info/top_level.txt

@@ -1 +0,0 @@
-PyCyphORM

PyCyphORM-0.1.3/README.md

@@ -1,45 +0,0 @@
-# PyCyphOrm
-
-A Minimalistic SQLite InMemory Encrypted ORM
-
-## Usage
-
-### Command Line Interface
-
-```sh
-usage: PyCyphORM [-h] [-i INIT] [-d FILEPATH]
-
-A Minimalistic SQLite InMemory Encrypted ORM
-
-options:
-  -h, --help            show this help message and exit
-  -i INIT, --init INIT  Initialize Salt and Password for
-                        Encrypted Database
-  -d FILEPATH, --decrypt FILEPATH
-                        Descrypt SQLite Database
-```
-
-### Example
-
-```python
-
-from PyCyphORM.lib import load_config, ORM
-
-cnf = load_config(".pyorm")
-orm = ORM.instance(".cache", cnf["PASSWORD"], cnf["SALT"], {
-    "Note": {
-        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
-        "title": "TEXT NOT NULL",
-        "description": "TEXT NOT NULL",
-        
-    }
-})
-
-orm.model("Note").insert({
-    "title": "Your Title #1",
-    "description": "Your Descriptioj #2",
-})
-
-orm.save()
-
-```

PyCyphORM-0.1.3/setup.py

@@ -1,27 +0,0 @@
-import os
-import setuptools
-
-# pip install ./PyORM --upgrade -t /home/jam/.local/lib/python3.10/site-packages/PyORM
-
-readme = open("%s%sREADME.md"%(os.path.dirname(__file__), os.path.sep)).read()
-
-
-setuptools.setup(
-    name='PyCyphORM',
-    version='0.1.3',
-    author='jafrmartins',
-    keywords='sqlite encrypted inmemory orm',
-    author_email='j.afr.martins@outlook.pt',
-    description='A Minimalistic SQLite InMemory Encrypted ORM',
-    packages=setuptools.find_packages('src'),
-    install_requires=[],
-    package_dir={'PyCyphORM': 'src/PyCyphORM', },
-    entry_points={
-        'console_scripts': [
-            'pycyphorm=cli:cli',
-        ],
-    },
-    include_package_data=True,
-    long_description=readme,
-    long_description_content_type='text/markdown'
-)

PyCyphORM-0.1.3/src/PyCyphORM/__init__.py

@@ -1,3 +0,0 @@
-from .lib.adapter import load_config
-from .lib.orm import ORM
-from .cli import cli

PyCyphORM-0.1.3/src/PyCyphORM/lib/__init__.py

@@ -1,2 +0,0 @@
-from .adapter import load_config
-from .orm import ORM