PyCyphORM 0.1.2__py3-none-any.whl → 0.1.2.dev1__py3-none-any.whl

PyCyphORM/__init__.py

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

{src → PyCyphORM}/cli.py

@@ -36,7 +36,7 @@ def cli():
     elif args['decrypt']:
         if path.exists(path.abspath(args['decrypt'])):
             
-            from src.lib.adapter import decrypt_cdb, load_config
+            from .lib.adapter import decrypt_cdb, load_config
             
             cnf = load_config(".pyorm")
             decrypt_cdb(path.abspath(args['decrypt']), cnf["PASSWORD"], cnf["SALT"])

PyCyphORM/lib/__init__.py

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

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/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)

{PyCyphORM-0.1.2.dist-info → PyCyphORM-0.1.2.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCyphORM
-Version: 0.1.2
+Version: 0.1.2.dev1
 Summary: A Minimalistic SQLite InMemory Encrypted ORM
 Author: jafrmartins
 Author-email: j.afr.martins@outlook.pt

PyCyphORM-0.1.2.dev1.dist-info/RECORD

@@ -0,0 +1,10 @@
+PyCyphORM/__init__.py,sha256=7XTdFpAvZBhwIEv-7ebj7Eex64JV_WFyTgRuVOx20Mg,82
+PyCyphORM/cli.py,sha256=At2Q8Fx2erRcV8YjDjLGfTXQaUKJ5Vk8FDw-nLca_uE,1391
+PyCyphORM/lib/__init__.py,sha256=2Br4Dx6sMIJLEHVL3P02LUoCcUnZbgZMlgGLxuglzaU,53
+PyCyphORM/lib/adapter.py,sha256=qLeiraGsm9OSzhie6j6XbGRmCknylBU5J7EsOtBLatU,1836
+PyCyphORM/lib/orm.py,sha256=9KOWv5yQngoN5M3ky_W9KEkMOfGCUXVF6Vl1Xt-9GlA,5212
+PyCyphORM-0.1.2.dev1.dist-info/METADATA,sha256=mFRGmiSRJcN_1HevXyZp4-w_scHlyctZYNLJdSTS0t4,1135
+PyCyphORM-0.1.2.dev1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+PyCyphORM-0.1.2.dev1.dist-info/entry_points.txt,sha256=6R4UorjfxYmbqjbF9d1fgmQybp5Zgy4Bw6PclOdO31Q,38
+PyCyphORM-0.1.2.dev1.dist-info/top_level.txt,sha256=ahpJTN6d1ACvc5oQSlPWSKmmaTqLyo7ctzhwNYoCCbA,10
+PyCyphORM-0.1.2.dev1.dist-info/RECORD,,

PyCyphORM-0.1.2.dev1.dist-info/top_level.txt

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

PyCyphORM-0.1.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-src/__init__.py,sha256=QL_yeVt2TuLjQoDbY8utuRUxvk_B-DGHbBM-tAf91dw,91
-src/cli.py,sha256=z5xOtyWibyx7RkCgOtAAxX_Rd5JATvH-VkNVRyN83S0,1394
-PyCyphORM-0.1.2.dist-info/METADATA,sha256=HPAqg6pGrCd5_P9PK2EYS3KSJDeWzfzBFEH8J7QnSis,1130
-PyCyphORM-0.1.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-PyCyphORM-0.1.2.dist-info/entry_points.txt,sha256=6R4UorjfxYmbqjbF9d1fgmQybp5Zgy4Bw6PclOdO31Q,38
-PyCyphORM-0.1.2.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
-PyCyphORM-0.1.2.dist-info/RECORD,,

PyCyphORM-0.1.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-src

src/__init__.py

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