arkilian 1.0.0__tar.gz

arkilian-1.0.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: arkilian
+Version: 1.0.0
+Summary: Arkilian - SQLite wrapper with automated cloud backup
+Author: CodeDynasty-dev
+License: MIT
+Project-URL: Homepage, https://github.com/CodeDynasty-dev/birth-of-Arkilian
+Project-URL: Repository, https://github.com/CodeDynasty-dev/birth-of-Arkilian
+Keywords: sqlite,database,backup,s3,c,ffi
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cffi>=1.15.0

arkilian-1.0.0/arkilian/__init__.py

@@ -0,0 +1,127 @@
+from .binding import lib, ffi
+
+SQLITE_OK = 0
+SQLITE_ROW = 100
+SQLITE_DONE = 101
+SQLITE_ERROR = 1
+
+
+class Arkilian:
+    def __init__(self, db_path="app.sqlite"):
+        self._db = ffi.new("arkilian**")
+        result = lib.db_init(self._db, db_path.encode())
+        if result != 0:
+            raise RuntimeError("Failed to initialize database: " + self.last_error)
+        if self._db[0] is None:
+            raise RuntimeError("Database handle is null")
+
+    def close(self):
+        if self._db and self._db[0]:
+            lib.db_close(self._db[0])
+            self._db = None
+
+    def exec(self, sql):
+        result = lib.db_exec(self._db[0], sql.encode())
+        if result != SQLITE_OK and result != SQLITE_DONE:
+            raise RuntimeError(self.last_error)
+        return result
+
+    def prepare(self, sql):
+        result = lib.db_prepare(self._db[0], sql.encode())
+        if result != SQLITE_OK:
+            raise RuntimeError(self.last_error)
+        return self
+
+    def step(self):
+        return lib.db_step(self._db[0])
+
+    def finalize(self):
+        result = lib.db_finalize(self._db[0])
+        if result != SQLITE_OK:
+            raise RuntimeError(self.last_error)
+        return self
+
+    def reset(self):
+        result = lib.db_reset(self._db[0])
+        if result != SQLITE_OK:
+            raise RuntimeError(self.last_error)
+        return self
+
+    def column_count(self):
+        return lib.db_column_count(self._db[0])
+
+    def column_name(self, col):
+        return ffi.string(lib.db_column_name(self._db[0], col)).decode()
+
+    def column_text(self, col):
+        ptr = lib.db_column_text(self._db[0], col)
+        return ffi.string(ptr).decode() if ptr else None
+
+    def column_int(self, col):
+        return lib.db_column_int(self._db[0], col)
+
+    def column_double(self, col):
+        return lib.db_column_double(self._db[0], col)
+
+    def bind_text(self, idx, value):
+        result = lib.db_bind_text(self._db[0], idx, value.encode())
+        if result != SQLITE_OK:
+            raise RuntimeError(self.last_error)
+        return self
+
+    def bind_int(self, idx, value):
+        result = lib.db_bind_int(self._db[0], idx, value)
+        if result != SQLITE_OK:
+            raise RuntimeError(self.last_error)
+        return self
+
+    def bind_double(self, idx, value):
+        result = lib.db_bind_double(self._db[0], idx, value)
+        if result != SQLITE_OK:
+            raise RuntimeError(self.last_error)
+        return self
+
+    def run(self, sql, params=None):
+        self.prepare(sql)
+        if params:
+            for i, p in enumerate(params):
+                if isinstance(p, str):
+                    self.bind_text(i + 1, p)
+                elif isinstance(p, int):
+                    self.bind_int(i + 1, p)
+                else:
+                    self.bind_double(i + 1, p)
+        self.step()
+        self.finalize()
+        return self
+
+    def all(self, sql, params=None):
+        results = []
+        self.prepare(sql)
+        if params:
+            for i, p in enumerate(params):
+                if isinstance(p, str):
+                    self.bind_text(i + 1, p)
+                elif isinstance(p, int):
+                    self.bind_int(i + 1, p)
+                else:
+                    self.bind_double(i + 1, p)
+        columns = [self.column_name(i) for i in range(self.column_count())]
+        while self.step() == SQLITE_ROW:
+            row = {}
+            for i, col in enumerate(columns):
+                row[col] = self.column_text(i)
+            results.append(row)
+        self.finalize()
+        return results
+
+    @property
+    def last_error(self):
+        return ffi.string(lib.db_errmsg(self._db[0])).decode() if self._db and self._db[0] else ""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False

arkilian-1.0.0/arkilian/binding.py

@@ -0,0 +1,52 @@
+import os
+import sys
+import cffi
+
+ffi = cffi.FFI()
+
+ffi.cdef("""
+typedef struct arkilian arkilian;
+
+int db_init(arkilian **db, const char *connection_url);
+void db_close(arkilian *db);
+const char* db_errmsg(arkilian *db);
+
+int db_exec(arkilian *db, const char *sql);
+int db_prepare(arkilian *db, const char *sql);
+int db_step(arkilian *db);
+int db_finalize(arkilian *db);
+int db_reset(arkilian *db);
+int db_column_count(arkilian *db);
+const char* db_column_name(arkilian *db, int col);
+const char* db_column_text(arkilian *db, int col);
+int db_column_int(arkilian *db, int col);
+double db_column_double(arkilian *db, int col);
+int db_bind_text(arkilian *db, int idx, const char *val);
+int db_bind_int(arkilian *db, int idx, int val);
+int db_bind_double(arkilian *db, int idx, double val);
+""")
+
+this_dir = os.path.dirname(os.path.abspath(__file__))
+src_dir = os.path.join(this_dir, "..", "..", "..", "build")
+
+lib_name = "libarkilian.dylib" if sys.platform == "darwin" else "libarkilian.so"
+lib_path = os.path.join(src_dir, lib_name)
+
+if not os.path.exists(lib_path):
+    lib_path = os.path.join(src_dir, "Release", lib_name)
+
+if not os.path.exists(lib_path):
+    lib_path = os.path.join(src_dir, "Release", "libarkilian.1.0.0.dylib")
+
+if not os.path.exists(lib_path):
+    lib_path = os.path.join(src_dir, "Release", "libarkilian.1.dylib")
+
+if not os.path.exists(lib_path):
+    lib_path = os.path.join(src_dir, "Release", "libarkilian.1.0.0.so")
+
+if not os.path.exists(lib_path):
+    raise RuntimeError(f"Library not found at {lib_path}")
+
+lib = ffi.dlopen(lib_path)
+
+__all__ = ["ffi", "lib"]

arkilian-1.0.0/arkilian/py.typed

@@ -0,0 +1 @@
+# PEP 561 marker file

arkilian-1.0.0/arkilian.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: arkilian
+Version: 1.0.0
+Summary: Arkilian - SQLite wrapper with automated cloud backup
+Author: CodeDynasty-dev
+License: MIT
+Project-URL: Homepage, https://github.com/CodeDynasty-dev/birth-of-Arkilian
+Project-URL: Repository, https://github.com/CodeDynasty-dev/birth-of-Arkilian
+Keywords: sqlite,database,backup,s3,c,ffi
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cffi>=1.15.0

arkilian-1.0.0/arkilian.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+arkilian/__init__.py
+arkilian/binding.py
+arkilian/py.typed
+arkilian.egg-info/PKG-INFO
+arkilian.egg-info/SOURCES.txt
+arkilian.egg-info/dependency_links.txt
+arkilian.egg-info/requires.txt
+arkilian.egg-info/top_level.txt

arkilian-1.0.0/arkilian.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

arkilian-1.0.0/arkilian.egg-info/requires.txt

@@ -0,0 +1 @@
+cffi>=1.15.0

arkilian-1.0.0/arkilian.egg-info/top_level.txt

@@ -0,0 +1 @@
+arkilian

arkilian-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0", "cffi>=1.15.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "arkilian"
+version = "1.0.0"
+description = "Arkilian - SQLite wrapper with automated cloud backup"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "CodeDynasty-dev"}]
+keywords = ["sqlite", "database", "backup", "s3", "c", "ffi"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = ["cffi>=1.15.0"]
+
+[project.urls]
+Homepage = "https://github.com/CodeDynasty-dev/birth-of-Arkilian"
+Repository = "https://github.com/CodeDynasty-dev/birth-of-Arkilian"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["arkilian*"]
+
+[tool.setuptools.package-data]
+arkilian = ["*.h"]

arkilian-1.0.0/setup.cfg

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