drifTech-lib 0.1.0__tar.gz

driftech_lib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 driftbluestone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

driftech_lib-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: drifTech-lib
+Version: 0.1.0
+Summary: Common files/functions across most drifTech software
+Author: driftbluestone
+Author-email: driftbluestone <driftbluestone@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14
+Project-URL: Source, https://github.com/driftbluestone/drifTech-lib
+Description-Content-Type: text/markdown
+
+Common files/functions across most drifTech software

driftech_lib-0.1.0/README.md

@@ -0,0 +1 @@
+Common files/functions across most drifTech software

driftech_lib-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = [
+    "uv_build >= 0.12.5, <0.13.0",
+    "psycopg[binary]",
+    "orjson",
+]
+build-backend = "uv_build"
+
+[project]
+name = "drifTech-lib"
+version = "0.1.0"
+description = "Common files/functions across most drifTech software"
+readme = "README.md"
+requires-python = ">=3.14"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[[project.authors]]
+name = "driftbluestone"
+email = "driftbluestone@gmail.com"
+
+[project.urls]
+Source = "https://github.com/driftbluestone/drifTech-lib"

driftech_lib-0.1.0/pyproject.toml.orig

@@ -0,0 +1,24 @@
+[build-system]
+requires = [
+    "uv_build >= 0.12.5, <0.13.0",
+    "psycopg[binary]",
+    "orjson"
+    ]
+build-backend = "uv_build"
+
+[project]
+name = "drifTech-lib"
+version = "0.1.0"
+authors = [{name = "driftbluestone", email = "driftbluestone@gmail.com"}]
+description = "Common files/functions across most drifTech software"
+readme = "README.md"
+requires-python = ">=3.14"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Source = "https://github.com/driftbluestone/drifTech-lib"

driftech_lib-0.1.0/src/driftech_lib/__init__.py

@@ -0,0 +1,2 @@
+from . import db, jsonIO
+__all__ = ["db", "jsonIO"]

driftech_lib-0.1.0/src/driftech_lib/db.py

@@ -0,0 +1,132 @@
+"""
+Module for interacting with PostgreSQL
+"""
+import psycopg, logging
+from typing import Any
+from psycopg import sql
+
+__all__ = ["SCHEMA", "run", "single", "multiple", "insert", "delete", "get", "table"]
+
+SCHEMA: sql.Identifier = None
+cursor: psycopg.Cursor = None
+connection: psycopg.Connection = None
+
+def table(name: str, columns: list[str]):
+    """
+    Create a table. Columns should be formatted like `column_name TYPE` e.g. `server_id BIGINT PRIMARY KEY` or `data JSONB`
+    """
+    run(f"CREATE TABLE IF NOT EXISTS {SCHEMA.as_string()}.{name} ({", ".join(columns)});")
+
+def check_connection():
+    cursor.execute("SELECT version();")
+    db_version = cursor.fetchone()
+    
+    logging.info("Connection Successful")
+    logging.info(f"PostgreSQL version: {db_version[0]}")
+
+def close_connection():
+    cursor.close()
+    connection.close()
+    logging.info("Database connection closed.")
+
+def run(*args):
+    cursor.execute(*args)
+    connection.commit()
+
+def single(*args):
+    cursor.execute(*args)
+    result = cursor.fetchone()
+    if isinstance(result, tuple) and len(result) == 1:
+        return result[0]
+    return result
+
+def multiple(*args):
+    cursor.execute(*args)
+    return cursor.fetchall()
+
+def insert(table: str, key: tuple[str, ...], field: tuple[str, ...], value: tuple[Any, ...]):
+    """Actually an upsert function."""
+    if not isinstance(key, tuple):
+        raise ValueError("Argument `key` must be a tuple.")
+    if not isinstance(field, tuple):
+        raise ValueError("Argument `field` must be a tuple.")
+    if not isinstance(value, tuple):
+        raise ValueError("Argument `value` must be a tuple.")
+    if len(key) + len(field) != len(value):
+        raise ValueError("len(key) + len(field) must equal len(value).")
+    if not key:
+        raise ValueError("Arguments `key`, `field`, and `value` cannot be empty.")
+    
+    query = "INSERT INTO {schema}.{table} ({fields}) VALUES ({values}) ON CONFLICT ({keys}) DO"
+    if field:
+        query += " UPDATE SET {assignments}"
+    else:
+        query += " NOTHING"
+
+    query = sql.SQL(query).format(
+        schema = SCHEMA,
+        table = sql.Identifier(table),
+        fields = sql.SQL(", ").join(sql.Identifier(f) for f in (key + field)),
+        values = sql.SQL(", ").join(sql.Placeholder() for _ in value),
+        keys = sql.SQL(", ").join(sql.Identifier(k) for k in key),
+        assignments = sql.SQL(", ").join(sql.SQL("{f} = EXCLUDED.{f}").format(
+            f=sql.Identifier(f)) for f in field if f not in key
+        )
+    )
+    run(query, value)
+
+def delete(table: str, key: tuple[str, ...], value: tuple[Any, ...]):
+    if not isinstance(key, tuple):
+        raise ValueError("Argument `key` must be a tuple")
+    if not isinstance(value, tuple):
+        raise ValueError("Argument `value` must be a tuple")
+    if len(key) != len(value):
+        raise ValueError("Arguments `key` and `value` must be equal in length")
+    if not key:
+        raise ValueError("Arguments `key` and `value` cannot be empty")
+    
+    query = sql.SQL("DELETE FROM {schema}.{table} WHERE {key}").format(
+        schema = SCHEMA,
+        table = sql.Identifier(table),
+        key = sql.SQL(" AND ").join(sql.SQL("{k} = %s").format(
+            k = sql.Identifier(k)) for k in key
+        )
+    )
+    run(query, value)
+
+def get(table: str, value: tuple[Any], key: tuple[str], column: tuple[str]):
+    if not isinstance(key, tuple):
+        raise ValueError("Argument `key` must be a tuple")
+    if not isinstance(value, tuple):
+        raise ValueError("Argument `value` must be a tuple")
+    if len(key) != len(value):
+        raise ValueError("Arguments `key` and `value` must be equal in length")
+    if not key:
+        raise ValueError("Arguments `key` and `value` cannot be empty")
+    
+    query = sql.SQL("SELECT {column} FROM {schema}.{table} WHERE {key}").format(
+        schema = SCHEMA,
+        table = sql.Identifier(table),
+        column = sql.SQL(", ").join(sql.Identifier(c) for c in column), # CANNOT PUT "*" IN HERE
+        key = sql.SQL(" AND ").join(sql.SQL("{k} = %s").format(
+            k = sql.Identifier(k)) for k in key
+        )
+    )
+    
+    return single(query, value)
+
+def start(schema: str, host: str, name: str, user: str, password: str, port: int):
+    global SCHEMA, connection, cursor
+    SCHEMA = sql.Identifier(schema)
+    logging.info("Connecting to database...")
+    connection = psycopg.connect(
+        host=host,
+        dbname=name,
+        user=user,
+        password=password,
+        port=port
+    )
+    cursor = connection.cursor()
+    check_connection()
+    logging.info("Connected to database.")
+    connection.execute(f"CREATE SCHEMA IF NOT EXISTS {SCHEMA.as_string()};")

driftech_lib-0.1.0/src/driftech_lib/jsonIO.py

@@ -0,0 +1,55 @@
+"""
+Module for writing / reading json with orjson
+
+Functions prefixed with `a` are asyncronous and run on a seperate thread,
+
+Functions suffixed with `s` or `b` input / return string or bytes, respectively
+"""
+import orjson, asyncio
+from pathlib import Path
+from orjson import JSONDecodeError
+__all__ = [
+    "read", "load", "write", "dump",
+    "dumps", "dumpb", "loads", "loadb",
+    "aread", "aload", "awrite", "adump",
+    "JSONDecodeError"
+    ]
+def read(path: str | Path) -> object:
+    with open(path, "rb") as file:
+        return orjson.loads(file.read())
+
+def load(path: str | Path) -> object:
+    with open(path, "rb") as file:
+        return orjson.loads(file.read())
+
+def write(path: str | Path, data, indent: int = True) -> None:
+    with open(path, "wb") as file:
+        file.write(orjson.dumps(data, option=1 if indent else None))
+
+def dump(path: str | Path, data, indent: int = True) -> None:
+    with open(path, "wb") as file:
+        file.write(orjson.dumps(data, option=1 if indent else None))
+
+def dumps(data) -> str:
+    return orjson.dumps(data).decode()
+
+def dumpb(data) -> bytes:
+    return orjson.dumps(data)
+
+def loads(data: str) -> object:
+    return orjson.loads(data.encode())
+
+def loadb(data: bytes) -> object:
+    return orjson.loads(data)
+
+async def aread(path: str | Path) -> object:
+    return await asyncio.to_thread(read, path)
+
+async def aload(path: str | Path) -> object:
+    return await asyncio.to_thread(load, path)
+
+async def awrite(path: str | Path, data, indent: int = True) -> None:
+    return await asyncio.to_thread(write, path, data, indent)
+
+async def adump(path: str | Path, data, indent: int = True) -> None:
+    return await asyncio.to_thread(dump, path, data, indent)