PyCyphORM 0.1.3__tar.gz

PyCyphORM-0.1.3/PKG-INFO

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

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

@@ -0,0 +1,12 @@
+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/dependency_links.txt

@@ -0,0 +1 @@
+

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

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

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

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

PyCyphORM-0.1.3/README.md

@@ -0,0 +1,45 @@
+# 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.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

PyCyphORM-0.1.3/setup.py

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

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

PyCyphORM-0.1.3/src/PyCyphORM/cli.py

@@ -0,0 +1,45 @@
+#!/bin/env python3
+
+import argparse
+
+from os import urandom, path
+from base64 import b16encode
+import random
+
+import json
+
+def random_password():
+    password = ""
+    characters = "abcdefghijklmnopqrstuvxyz0123456789~/|#$%&()"
+    for index in range(12):
+        password = password + random.choice(characters)
+    return password
+
+parser = argparse.ArgumentParser(
+    prog = 'PyCyphORM',
+    description = 'A Minimalistic SQLite InMemory Encrypted 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")
+
+def cli():
+    args = vars(parser.parse_args())
+    if args["init"]:
+        with open(".pyorm", "w") as f:
+            f.write(json.dumps({
+                "SALT": b16encode(urandom(16)).decode("utf-8"),
+                "PASSWORD": b16encode(bytes(random_password(), "utf-8")).decode("utf-8")
+            }))
+
+    elif args['decrypt']:
+        if path.exists(path.abspath(args['decrypt'])):
+            
+            from .lib.adapter import decrypt_cdb, load_config
+            
+            cnf = load_config(".pyorm")
+            decrypt_cdb(path.abspath(args['decrypt']), cnf["PASSWORD"], cnf["SALT"])
+
+
+if __name__ == "__main__": cli()

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

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

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

@@ -0,0 +1,68 @@
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.backends import default_backend
+import json
+
+import sqlite3
+import gzip
+import os
+
+from base64 import b16decode, urlsafe_b64encode
+
+def load_config(filepath):
+    config = None
+    with open(filepath, "rb") as f:
+        config = json.loads(f.read())
+    for key in config:
+        if isinstance(config[key], str):
+            config[key] = b16decode(config[key])
+    return config
+
+def key_creation(password, salt):
+    kdf=PBKDF2HMAC(algorithm = hashes.SHA256(), salt=salt, iterations=1024, length=32, backend=default_backend())
+    key=Fernet(urlsafe_b64encode(kdf.derive(password)))
+    return key
+
+def encryption(b, password, salt):
+    f=key_creation(password, salt)
+    safe=f.encrypt(b)
+    return safe
+
+def decryption(safe, password, salt):
+    f=key_creation(password, salt)
+    b=f.decrypt(safe)
+    return b
+
+def open_cdb(filename, password, salt):
+    if not os.path.exists(filename):
+        con = sqlite3.connect(':memory:')
+        return con
+    f=gzip.open(filename,'rb')
+    safe=f.read()
+    f.close()
+    content=decryption(safe,password,salt)
+    content=content.decode('utf-8')
+    con=sqlite3.connect(':memory:')
+    con.executescript(content)
+    return con
+
+def decrypt_cdb(filename, password, salt):
+    f=gzip.open(filename,'rb')
+    safe=f.read()
+    f.close()
+    content=decryption(safe,password,salt)
+    fp=gzip.open(filename+".decoded.db",'wb')
+    fp.write(content)
+    fp.close()
+
+def save_cdb(con, filename, password, salt):
+    fp=gzip.open(filename,'wb')
+    b=b''
+    for line in con.iterdump():
+        b+=bytes('%s\n','utf8') % bytes(line,'utf8')
+    b=encryption(b,password, salt)
+    fp.write(b)
+    fp.close()
+
+

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

@@ -0,0 +1,175 @@
+from .adapter import open_cdb, save_cdb
+import os
+
+class QueryBuilder:
+
+    @staticmethod
+    def __where__(clause):
+        where = []
+        for k in clause:
+            if clause[k] == None:
+                where.append("%s IS NULL" % (k))
+            else:
+                where.append("%s = \"%s\"" % (k, clause[k]))
+        return ",".join(where)
+
+    @staticmethod
+    def __set__(clause):
+        st = []
+        for k in clause:
+            if clause[k] == None:
+                st.append("%s = NULL" % (k))
+            else:
+                st.append("%s = \"%s\"" % (k, clause[k]))
+        return ",".join(st)
+
+    @staticmethod
+    def __insert__(table, data):
+        if isinstance(data, dict):
+            columns = []
+            values = []
+            for column in data:
+                columns.append(column)
+                values.append("\"%s\"" % data[column])
+            sql = "INSERT INTO %s (%s) VALUES (%s)" % (table, ",".join(columns), ",".join(values))
+        else:
+            count = 0
+            columns = []
+            bulk = []
+            for row in data:
+                values = []
+                for column in row:
+                    if count == 0:
+                        columns.append(column)
+                    values.append("\"%s\"" % data[column])
+                count += 1
+                bulk.append("(%s)" % (",".join(values)))
+            sql = "INSERT INTO %s (%s) VALUES %s" % (table, ",".join(columns), ",".join(bulk))
+        return sql   
+    
+    @staticmethod
+    def __create_table__(table, schema):
+        definition = []
+        for column in schema:
+            definition.append("%s %s" % (column, schema[column]))
+        sql = "CREATE TABLE %s (%s)" % (table, ",".join(definition))
+        return sql
+
+    @staticmethod
+    def __drop_table__(table):
+        sql = "DROP TABLE %s" % (table)
+        return sql
+
+    def __update__(self, table, data, where):
+        sql = "UPDATE %s SET %s" % (table, self.__set__(data))
+        if isinstance(where, dict):
+            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):
+            sql += " WHERE %s" % self.__where__(where)
+        if isinstance(orderby, str):
+            sql += " ORDER BY %s" % (orderby)
+        return sql
+
+    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):
+        self.conn = conn
+        self.table = table
+        self.schema = schema
+
+    def down(self):
+        sql = self.__drop_table__(self.table)
+        cur = self.conn.cursor()
+        cur.execute(sql)
+        self.conn.commit()
+        return cur.rowcount
+    
+    def up(self):
+        sql = self.__create_table__(self.table, self.schema)
+        cur = self.conn.cursor()
+        cur.execute(sql)
+        self.conn.commit()
+        return cur.rowcount
+
+    def insert(self, data):
+        sql = self.__insert__(self.table, data)
+        cur = self.conn.cursor()
+        cur.execute(sql)
+        self.conn.commit()
+        return cur.lastrowid
+
+    def update(self, where, data):
+        sql = self.__update__(self.table, data, where)
+        cur = self.conn.cursor()
+        cur.execute(sql)
+        self.conn.commit()
+        return cur.rowcount
+
+    def delete(self, where):
+        sql = self.__delete__(self.table, where)        
+        cur = self.conn.cursor()
+        cur.execute(sql)
+        self.conn.commit()
+        return cur.rowcount
+
+    def find(self, where=None):
+        sql = self.__select__(self.table, ["*"], where)
+        cur = self.conn.cursor()
+        cur.execute(sql)
+        rows = cur.fetchall()
+        return rows
+
+    def first(self, where):
+        sql = self.__select__(self.table, ["*"], where)
+        cur = self.conn.cursor()
+        cur.execute(sql)
+        row = cur.fetchone()
+        return row
+
+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__
+
+    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
+        
+        self.conn = open_cdb(self.filename, self.password, self.salt)
+
+        for table in schema:
+            self.__models__[table] = Model(self.conn, table, schema[table])
+            if install:
+                self.__models__[table].up()
+        if install:
+            save_cdb(self.conn, self.filename, self.password, self.salt)
+
+    def model(self, name) -> Model|None:
+        if name in self.__models__:
+            return self.__models__[name]
+        return None
+    
+    def save(self):
+        save_cdb(self.conn, self.filename, self.password, self.salt)