sqlthon 0.0.2__tar.gz → 0.0.5__tar.gz

{sqlthon-0.0.2 → sqlthon-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlthon
-Version: 0.0.2
+Version: 0.0.5
 Summary: A simple package for SQLite3 operations
 Author-email: SAUMS <mohamnown@gmail.com>
 License: MIT

{sqlthon-0.0.2 → sqlthon-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlthon"
-version = "0.0.2"
+version = '0.0.5'
 description = "A simple package for SQLite3 operations"
 readme = "README.md"
 requires-python = ">=3.8"

sqlthon-0.0.5/src/sqlthon/__init__.py

@@ -0,0 +1,11 @@
+"""
+Sqlthon - A Simple Package For SQLite3 Operations.
+"""
+
+from .core import Connect, Field
+
+__all__ = ['Connect', 'Field']
+__version__ = '0.0.5'
+__author__ = "SAUMS"
+__email__ = "saums1391@gmail.com"
+__description__ = "Operate With SQLite3 Buy Simple"

sqlthon-0.0.5/src/sqlthon/core.py

@@ -0,0 +1,156 @@
+class Field:
+    def __init__(self, name):
+        self.name = name
+    
+    def __gt__(self, value): return _Expression(self, ">", value)
+    def __lt__(self, value): return _Expression(self, "<", value)
+    def __ge__(self, value): return _Expression(self, ">=", value)
+    def __le__(self, value): return _Expression(self, "<=", value)
+    def __eq__(self, value): return _Expression(self, "=", value)
+    def __ne__(self, value): return _Expression(self, "!=", value)
+
+
+class _Expression:
+    def __init__(self, left, op, right):
+        self.left = left
+        self.op = op
+        self.right = right
+    
+    def __and__(self, other):
+        return _Expression(self, "AND", other)
+    def __or__(self, other):
+        return _Expression(self, "OR", other)
+       
+       
+def _compile(expr):
+    if isinstance(expr.left, _Expression) or isinstance(expr.right, _Expression):
+        left_sql, left_params = compile(expr.left)
+        right_sql, right_params = compile(expr.right)
+        sql = f"{left_sql} {expr.op} {right_sql}"
+        params = left_params + right_params
+        return sql, params
+    
+    else:
+        field_name = expr.left.name
+        sql = f'"{field_name}" {expr.op} ?'
+        params = (expr.right,)
+        return sql, params
+
+
+
+
+
+
+
+class Connect:
+    __slots__ = ("_con", "_cur", "_changes")
+    def __init__(self, database_path: str) -> None:
+        from sqlite3 import connect as _cn
+        self._con = _cn(database_path)
+        self._cur = self._con.cursor()
+        self._changes = []
+        del _cn
+    
+    # ____________| TABLE |____________
+
+    def add_table(self, table_name: str, *columns: tuple, if_not_exists=False) -> None:
+        query = "CREATE TABLE "
+        if if_not_exists:
+            query += "IF NOT EXISTS "
+        query += f"{table_name} ("
+        for column in columns:
+            name, type = column[0], column[1]
+            try:
+                limits = column[2]
+                query += f"{name} {type} {" ".join(limits)}"
+            except IndexError:
+                query += f"{name} {type}"
+
+            query += ", "
+        query = query[:-2]+")"
+        self._changes.append((query,))
+    
+    def rename_table(self, old_name_table: str, new_name_table: str) -> None:
+        self._changes.append((f"ALTER TABLE {old_name_table} RENAME TO {new_name_table}",))
+        
+    def drop_table(self, table_name: str) -> None:
+        self._changes.append((f"DROP TABLE {table_name}",))
+    
+    def exist_table(self, table_name: str) -> bool:
+        return table_name in [i[0] for i in self.run_code("SELECT name FROM sqlite_master WHERE type='table'")]
+    
+    def copy_table(self, table_name: str, new_name_table: str) -> None:
+        self._changes.append((f"CREATE TABLE {new_name_table} AS SELECT * FROM {table_name}"),)
+    
+    # ____________| COLUMN |____________
+    def add_column(self, table_name: str, column_name: str, column_type: str, limits: list=[]) -> None:
+        if limits:
+            limits = " ".join(limits)
+        else:
+            limits = ""
+        self._changes.append((f"ALTER TABLE {table_name} ADD COLUMN {column_name} {column_type} {limits}",))
+    
+    def drop_column(self, table_name: str, column_name: str) -> None:
+        self._changes.append((f"ALTER TABLE {table_name} DROP COLUMN {column_name}",))
+    
+    def rename_column(self, table_name: str, old_name_column: str, new_name_column: str) -> None:
+        self._changes.append((f"ALTER TABLE {table_name} RENAME COLUMN {old_name_column} TO {new_name_column}",))
+    
+    def exist_column(self, table_name: str, column_name: str) -> bool:
+        return column_name in [i[1] for i in self.run_code(f"PRAGMA table_info({table_name})")]
+    
+    def get_columns(self, table_name: str) -> list:
+        return [i[1] for i in self.run_code(f"PRAGMA table_info({table_name})")]
+    
+    # ____________| RECORD |____________
+    def add_record(self, table_name: str, record_info: tuple) -> None:
+        self._changes.append((f"INSERT INTO {table_name} VALUES({', '.join(['?']*len(record_info))})", record_info))
+        
+    def delete_record(self, table_name, condition=None):
+        query = f"DELETE FROM {table_name}"
+        params = ()
+        if condition:
+            sql_where, params = _compile(condition)
+            query += " WHERE " + sql_where
+        self._changes.append((query, params))
+    
+    def edit_record(self, table_name, new_info_record, condition=None):
+        query = f"UPDATE {table_name} SET "
+        params = ()
+        
+        set_parts = []
+        for key, value in new_info_record.items():
+            set_parts.append(f'"{key}" = ?')
+            params += (value,)
+        query += ", ".join(set_parts)
+        
+        if condition:
+            sql_where, where_params = _compile(condition)
+            query += " WHERE " + sql_where
+            params += where_params
+        
+        self._changes.append((query, params))
+    
+    def count_record(self, table_name: str) -> int:
+        return self.run_code(f"SELECT COUNT(*) FROM {table_name}")[0][0]
+    
+    
+    # ____________| OTHER |_________
+
+    def run_code(self, code: str, parameters: tuple=()) -> list | None:
+        self._cur.execute(code, parameters)
+        self._con.commit()
+        try:
+            return self._cur.fetchall()
+        except:
+            pass
+    
+    def close(self):
+        self._con.close()
+    
+
+    def save_to_data_base(self) -> None:
+        with self._con:
+            for sql_code in self._changes:
+                self._cur.execute(*sql_code)
+        self._changes.clear()

{sqlthon-0.0.2 → sqlthon-0.0.5}/src/sqlthon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlthon
-Version: 0.0.2
+Version: 0.0.5
 Summary: A simple package for SQLite3 operations
 Author-email: SAUMS <mohamnown@gmail.com>
 License: MIT

sqlthon-0.0.2/src/sqlthon/__init__.py

@@ -1,11 +0,0 @@
-"""
-Sqlthon - A Simple Package For SQLite3 Operations.
-"""
-
-from .core import Connect
-
-__all__ = ['Connect']
-__version__ = "0.0.2"
-__author__ = "SAUMS"
-__email__ = "saums1391@gmail.com"
-__description__ = "Operate With SQLite3 Buy Simple"

sqlthon-0.0.2/src/sqlthon/core.py

@@ -1,106 +0,0 @@
-import sqlite3 as sq
-
-
-class Connect:
-    __slots__ = ("_con", "_cur", "_changes")
-    def __init__(self, path: str) -> None:
-        self._con = sq.connect(path)
-        self._cur = self._con.cursor()
-        self._changes = []
-    
-        
-    class Column:
-        __slots__ = ("_name", "_type", "_limits")
-        def __init__(self, name_column: str, type: str="", limits: list=[]):
-            self._name = name_column
-            self._type = " "+type if type else ""
-            self._limits = limits
-    
-    
-    def add_table(self, name_table: str, *columns: Column, if_not_exist: bool=False) -> None:
-        text = "CREATE TABLE "
-        if if_not_exist:
-            text += "IF NOT EXISTS "
-        text += f"{name_table} ("
-        for column in columns:
-            text += column._name + column._type
-            if column._limits:
-                text += " " + str(column._limits).replace("[", "").replace("'", "").replace("]", "").replace(",", "")
-            text += ", "
-        text = f"{text[:-2]})"
-        
-        self._changes.append((text,))
-    
-    
-    def add_record(self, name_table: str, *record: list) -> None:
-        self._changes.append((f"INSERT INTO {name_table} VALUES ({"?, "*(len(record)-1)}?)", record))
-    
-    
-    def find_table(self, word: str="") -> list:
-        self._cur.execute("SELECT name FROM sqlite_master WHERE type='table'")
-        tables = [tup[0] for tup in self._cur.fetchall()]
-        return [table for table in tables if word in table]
-
-
-    def find_record(self, name_table: str, columns: list|str="*", where: dict|str="") -> list:
-        text = "SELECT "
-        if type(columns) == list:
-            columns = str(columns).replace("[", "").replace("]", "").replace("'", "")
-        text += columns+" FROM "+name_table
-        if where:
-            equal = " WHERE " + str(list(where.keys())).replace("]", ", ").replace("[", "").replace("'", "").replace(", ", "=? and ")[:-5]
-            where = tuple(where.values())
-        try:
-            text += equal
-        except:
-            pass
-            
-        self._cur.execute(text, where)
-        return self._cur.fetchall()
-    
-    
-    def delete_table(self, name_table: str):
-        self._changes.append((f"DROP TABLE {name_table}",))
-    
-    
-    def delete_record(self, name_table: str, info_record: dict={}) -> None:
-        text = f"DELETE FROM {name_table}"
-        if info_record:
-            text += " WHERE "
-            equal = tuple(info_record.values())
-            info_record = str(list(info_record.keys())).replace("[", "").replace("'", "").replace("]", ", ").replace(", ", "=? ").replace(" ", " AND ")[:-5]
-        try:
-            equal
-            self._changes.append((text+info_record, equal))
-        except:
-            self._changes.append((text,))
-        
-        
-    def edit_record(self, name_table: str, new_record: dict, old_record: dict) -> None:
-        text = "UPDATE "+name_table+" SET "
-        equal = tuple(old_record.values())+tuple(new_record.values())
-        old_record = str(list(old_record.keys())).replace("[", "").replace("'", "").replace("]", ", ").replace(", ", "=? ").replace(" ", ", ")[:-2]
-        new_record = str(list(new_record.keys())).replace("[", "").replace("'", "").replace("]", ", ").replace(", ", "=? ").replace(" ", " AND ")[:-4]
-        
-        text += old_record+" WHERE "+new_record
-        self._changes.append((text, equal))
-    
-    
-    def run_code(self, code: str, parameters: tuple=()) -> list | None:
-        self._cur.execute(code, parameters)
-        self._con.commit()
-        try:
-            return self._cur.fetchall()
-        except:
-            pass
-    
-    
-    def close(self):
-        self._con.close()
-    
-
-    def save_to_data_base(self) -> None:
-        with self._con:
-            for sql_code in self._changes:
-                self._cur.execute(*sql_code)
-        self._changes.clear()