memberjojo 1.1__tar.gz → 2.0__tar.gz

{memberjojo-1.1 → memberjojo-2.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: memberjojo
-Version: 1.1
+Version: 2.0
 Summary: memberjojo - tools for working with members.
 Author-email: Duncan Bellamy <dunk@denkimushi.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-Expression: MIT
 License-File: LICENSE
+Requires-Dist: sqlcipher3
 Requires-Dist: coverage ; extra == "dev"
 Requires-Dist: flit ; extra == "dev"
 Requires-Dist: pytest ; extra == "dev"
@@ -23,16 +24,15 @@ Provides-Extra: lint
 
 # memberjojo
 
-`memberjojo` is a Python library for managing [Membermojo](http://membermojo.co.uk/)
+`memberjojo` is a Python library for using [Membermojo](http://membermojo.co.uk/)
 data from CSV imports.\
-It provides member database interactions, and transaction querying.\
-This is done in a local SQLite database, and does not alter anything on Membermojo.\
+It provides member database, and completed payments querying.\
+This is done in a local SQLite database which is encrypted, and does not alter
+anything on Membermojo.\
 It provides tools to load, and query membership and transaction data efficiently
 without having to use SQLite directly.\
-When importing CSV files existing entries are skipped, so you can just import the
-latest download and the local database is updated with new entries.\
-All the transaction data is imported into the database,
-but currently only a limited amount of member data is imported.
+When importing CSV files existing entries are dropped before import, so you can
+just import the latest download and the local database is updated.\
 
 ---
 
@@ -40,7 +40,21 @@ but currently only a limited amount of member data is imported.
 
 Install via `pip`:
 
+Installing via `pip` on macos with `sqlcipher` installed via homebrew:\
+(The sqlcipher bindings are compiled by pip so the `C_INCLUDE_PATH` is needed
+for 'clang' to be able to find the header files)\
+
+```bash
+brew install sqlcipher
+export C_INCLUDE_PATH="/opt/homebrew/opt/sqlcipher/include"
+export LIBRARY_PATH="/opt/homebrew/opt/sqlcipher/lib"
+pip install memberjojo
+```
+
+Installing via `pip` on ubuntu:
+
 ```bash
+sudo apt-get --no-install-recommends --no-install-suggests install libsqlcipher-dev
 pip install memberjojo
 ```
 
@@ -64,11 +78,11 @@ from membermojo import Member
 member_database_path = Path(Path(__file__).parent, "database", "my-members.db")
 member_csv_path = Path("download", "members.csv")
 
-members = Member(member_database_path)
+members = Member(member_database_path, "My DB Password")
 members.import_csv(member_csv_path)
 
 for member in members:
-    print(member.first_name, member.last_name, member.member_num)
+    print(member.first_name, member.last_name, member.member_number)
 
 # Get full name for a given member number
 found_name = members.get_name(1)

{memberjojo-1.1 → memberjojo-2.0}/README.md

@@ -1,15 +1,14 @@
 # memberjojo
 
-`memberjojo` is a Python library for managing [Membermojo](http://membermojo.co.uk/)
+`memberjojo` is a Python library for using [Membermojo](http://membermojo.co.uk/)
 data from CSV imports.\
-It provides member database interactions, and transaction querying.\
-This is done in a local SQLite database, and does not alter anything on Membermojo.\
+It provides member database, and completed payments querying.\
+This is done in a local SQLite database which is encrypted, and does not alter
+anything on Membermojo.\
 It provides tools to load, and query membership and transaction data efficiently
 without having to use SQLite directly.\
-When importing CSV files existing entries are skipped, so you can just import the
-latest download and the local database is updated with new entries.\
-All the transaction data is imported into the database,
-but currently only a limited amount of member data is imported.
+When importing CSV files existing entries are dropped before import, so you can
+just import the latest download and the local database is updated.\
 
 ---
 
@@ -17,7 +16,21 @@ but currently only a limited amount of member data is imported.
 
 Install via `pip`:
 
+Installing via `pip` on macos with `sqlcipher` installed via homebrew:\
+(The sqlcipher bindings are compiled by pip so the `C_INCLUDE_PATH` is needed
+for 'clang' to be able to find the header files)\
+
+```bash
+brew install sqlcipher
+export C_INCLUDE_PATH="/opt/homebrew/opt/sqlcipher/include"
+export LIBRARY_PATH="/opt/homebrew/opt/sqlcipher/lib"
+pip install memberjojo
+```
+
+Installing via `pip` on ubuntu:
+
 ```bash
+sudo apt-get --no-install-recommends --no-install-suggests install libsqlcipher-dev
 pip install memberjojo
 ```
 
@@ -41,11 +54,11 @@ from membermojo import Member
 member_database_path = Path(Path(__file__).parent, "database", "my-members.db")
 member_csv_path = Path("download", "members.csv")
 
-members = Member(member_database_path)
+members = Member(member_database_path, "My DB Password")
 members.import_csv(member_csv_path)
 
 for member in members:
-    print(member.first_name, member.last_name, member.member_num)
+    print(member.first_name, member.last_name, member.member_number)
 
 # Get full name for a given member number
 found_name = members.get_name(1)

{memberjojo-1.1 → memberjojo-2.0}/pyproject.toml

@@ -9,6 +9,7 @@ readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
 dynamic = ["version", "description"]
+dependencies = ["sqlcipher3"]
 requires-python = ">=3.8"
 
 [project.urls]
@@ -39,10 +40,9 @@ include = ["tests", "src/memberjojo/_version.py"]
 write_to = "src/memberjojo/_version.py"
 
 [tool.pytest.ini_options]
-pythonpath = [ "src" ]
+pythonpath = ["src"]
 
 [tool.pylint.main]
 output-format = "colorized"
 verbose = true
-ignore = ["docs"]
 ignore-patterns = ["_version.py"]

{memberjojo-1.1 → memberjojo-2.0}/src/memberjojo/__init__.py

@@ -8,5 +8,5 @@ except ModuleNotFoundError:
     # _version.py is written when building dist
     __version__ = "0.0.0+local"
 
-from .mojo_member import Member, MemberData
+from .mojo_member import Member
 from .mojo_transaction import Transaction

{memberjojo-1.1 → memberjojo-2.0}/src/memberjojo/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '1.1'
-__version_tuple__ = version_tuple = (1, 1)
+__version__ = version = '2.0'
+__version_tuple__ = version_tuple = (2, 0)
+
+__commit_id__ = commit_id = 'g9cd84a0d7'

memberjojo-2.0/src/memberjojo/mojo_common.py

@@ -0,0 +1,227 @@
+"""
+MojoSkel base class
+
+This module provides a common base class (`MojoSkel`) for other `memberjojo` modules.
+It includes helper methods for working with SQLite databases.
+"""
+
+# pylint: disable=no-member
+
+from dataclasses import make_dataclass
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import Union, List
+
+from sqlcipher3 import dbapi2 as sqlite3
+
+from . import mojo_loader
+
+
+class MojoSkel:
+    """
+    Establishes a connection to a SQLite database and provides helper methods
+    for querying tables.
+    """
+
+    def __init__(self, db_path: str, db_key: str, table_name: str):
+        """
+        Initialize the MojoSkel class.
+
+        Connects to the SQLite database and sets the row factory for
+        dictionary-style access to columns.
+
+        :param db_path: Path to the SQLite database file.
+        :param db_key: key to unlock the encrypted sqlite database, or encrypt new one.
+        :param table_name: Name of the table to operate on, or create when importing.
+        """
+        self.db_path = db_path
+        self.table_name = table_name
+        self.db_key = db_key
+
+        # Open connection
+        self.conn = sqlite3.connect(self.db_path)
+        self.conn.row_factory = sqlite3.Row
+        self.cursor = self.conn.cursor()
+
+        # Apply SQLCipher key
+        self.cursor.execute(f"PRAGMA key='{db_key}'")
+        self.cursor.execute("PRAGMA cipher_compatibility = 4")
+        print("Cipher:", self.cursor.execute("PRAGMA cipher_version;").fetchone()[0])
+        print(f"Encrypted database {self.db_path} loaded securely.")
+
+        # After table exists (or after import), build the dataclass
+        if self.table_exists(table_name):
+            self.row_class = self._build_dataclass_from_table()
+        else:
+            self.row_class = None
+
+    def __iter__(self):
+        """
+        Allow iterating over the class, by outputing all members.
+        """
+        if not self.row_class:
+            raise RuntimeError("Table not loaded yet — no dataclass available")
+        return self._iter_rows()
+
+    def _iter_rows(self):
+        """
+        Iterate over table rows and yield dynamically-created dataclass objects.
+        Converts REAL columns to Decimal automatically.
+        """
+
+        sql = f'SELECT * FROM "{self.table_name}"'
+
+        cur = self.conn.cursor()
+        cur.execute(sql)
+
+        for row in cur.fetchall():
+            row_dict = dict(row)
+
+            # Convert REAL → Decimal
+            for k, v in row_dict.items():
+                if isinstance(v, float):
+                    row_dict[k] = Decimal(str(v))
+                elif isinstance(v, str):
+                    # Try converting numeric strings
+                    try:
+                        row_dict[k] = Decimal(v)
+                    except InvalidOperation:
+                        pass
+
+            yield self.row_class(**row_dict)
+
+    def _build_dataclass_from_table(self):
+        """
+        Dynamically create a dataclass from the table schema.
+        INTEGER → int
+        REAL → Decimal
+        TEXT → str
+
+        :return: A dataclass built from the table columns and types.
+        """
+        self.cursor.execute(f'PRAGMA table_info("{self.table_name}")')
+        cols = self.cursor.fetchall()
+
+        if not cols:
+            raise ValueError(f"Table '{self.table_name}' does not exist")
+
+        fields = []
+        for _cid, name, col_type, _notnull, _dflt, _pk in cols:
+            t = col_type.upper()
+
+            if t.startswith("INT"):
+                py_type = int
+            elif t.startswith("REAL") or t.startswith("NUM") or t.startswith("DEC"):
+                py_type = Decimal
+            else:
+                py_type = str
+
+            fields.append((name, py_type))
+
+        return make_dataclass(f"{self.table_name}_Row", fields)
+
+    def import_csv(self, csv_path: Path):
+        """
+        import the passed CSV into the sqlite database
+
+        :param csv_path: Path like path of csv file.
+        """
+        mojo_loader.import_csv_helper(self.conn, self.table_name, csv_path)
+        self.row_class = self._build_dataclass_from_table()
+
+    def show_table(self, limit: int = 2):
+        """
+        Print the first few rows of the table as dictionaries.
+
+        :param limit: (optional) Number of rows to display. Defaults to 2.
+        """
+        if self.table_exists(self.table_name):
+            self.cursor.execute(f'SELECT * FROM "{self.table_name}" LIMIT ?', (limit,))
+            rows = self.cursor.fetchall()
+
+        else:
+            print("(No data)")
+            return
+
+        for row in rows:
+            print(dict(row))
+
+    def count(self) -> int:
+        """
+        :return: count of the number of rows in the table, or 0 if no table.
+        """
+        if self.table_exists(self.table_name):
+            self.cursor.execute(f'SELECT COUNT(*) FROM "{self.table_name}"')
+            result = self.cursor.fetchone()
+            return result[0] if result else 0
+
+        return 0
+
+    def get_row(self, entry_name: str, entry_value: str) -> dict:
+        """
+        Retrieve a single row matching column = value (case-insensitive).
+
+        :param entry_name: Column name to filter by.
+        :param entry_value: Value to match.
+
+        :return: The matching row as a dictionary, or None if not found.
+        """
+        if not entry_value:
+            return None
+        query = (
+            f'SELECT * FROM "{self.table_name}" WHERE LOWER("{entry_name}") = LOWER(?)'
+        )
+        self.cursor.execute(query, (entry_value,))
+        row = self.cursor.fetchone()
+        return dict(row) if row else None
+
+    def get_row_multi(
+        self, match_dict: dict, only_one: bool = True
+    ) -> Union[sqlite3.Row, List[sqlite3.Row], None]:
+        """
+        Retrieve one or many rows matching multiple column=value pairs.
+
+        :param match_dict: Dictionary of column names and values to match.
+        :param only_one: If True (default), return the first matching row.
+                        If False, return a list of all matching rows.
+
+        :return:
+            - If only_one=True → a single sqlite3.Row or None
+            - If only_one=False → list of sqlite3.Row (may be empty)
+        """
+        conditions = []
+        values = []
+
+        for col, val in match_dict.items():
+            if val is None or val == "":
+                conditions.append(f'"{col}" IS NULL')
+            else:
+                conditions.append(f'"{col}" = ?')
+                values.append(
+                    float(val.quantize(Decimal("0.01")))
+                    if isinstance(val, Decimal)
+                    else val
+                )
+
+        base_query = (
+            f'SELECT * FROM "{self.table_name}" WHERE {" AND ".join(conditions)}'
+        )
+
+        if only_one:
+            query = base_query + " LIMIT 1"
+            self.cursor.execute(query, values)
+            return self.cursor.fetchone()
+
+        # Return *all* rows
+        self.cursor.execute(base_query, values)
+        return self.cursor.fetchall()
+
+    def table_exists(self, table_name: str) -> bool:
+        """
+        Return true or false if a table exists
+        """
+        self.cursor.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1;",
+            (table_name,),
+        )
+        return self.cursor.fetchone() is not None

memberjojo-2.0/src/memberjojo/mojo_loader.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Helper module for importing a CSV into a SQLite database.
+"""
+
+from csv import DictReader
+from pathlib import Path
+import re
+from collections import defaultdict, Counter
+
+# -----------------------
+# Normalization & Type Guessing
+# -----------------------
+
+
+def _normalize(name: str) -> str:
+    """
+    Normalize a column name: lowercase, remove symbols, convert to snake case.
+
+    :param name: Raw name to normalize.
+
+    :return: Normalized lowercase string in snake case with no symbols.
+    """
+    name = name.strip().lower()
+    name = re.sub(r"[^a-z0-9]+", "_", name)
+    return name.strip("_")
+
+
+def _guess_type(value: any) -> str:
+    """
+    Guess SQLite data type of a CSV value: 'INTEGER', 'REAL', or 'TEXT'.
+    """
+    if value is None:
+        return "TEXT"
+    if isinstance(value, str):
+        value = value.strip()
+        if value == "":
+            return "TEXT"
+    try:
+        int(value)
+        return "INTEGER"
+    except (ValueError, TypeError):
+        try:
+            float(value)
+            return "REAL"
+        except (ValueError, TypeError):
+            return "TEXT"
+
+
+def infer_columns_from_rows(rows: list[dict]) -> dict[str, str]:
+    """
+    Infer column types from CSV rows.
+    Returns mapping: normalized column name -> SQLite type.
+    """
+    type_counters = defaultdict(Counter)
+
+    for row in rows:
+        for key, value in row.items():
+            norm_key = _normalize(key)
+            type_counters[norm_key][_guess_type(value)] += 1
+
+    inferred_cols = {}
+    for col, counter in type_counters.items():
+        if counter["TEXT"] == 0:
+            if counter["REAL"] > 0:
+                inferred_cols[col] = "REAL"
+            else:
+                inferred_cols[col] = "INTEGER"
+        else:
+            inferred_cols[col] = "TEXT"
+    return inferred_cols
+
+
+# -----------------------
+# Table Creation
+# -----------------------
+
+
+def _create_table_from_columns(table_name: str, columns: dict[str, str]) -> str:
+    """
+    Generate CREATE TABLE SQL from column type mapping.
+
+    :param table_name: Table to use when creating columns.
+    :param columns: dict of columns to create.
+
+    :return: SQL commands to create the table.
+    """
+    column_defs = [f'"{col}" {col_type}' for col, col_type in columns.items()]
+    return (
+        f'CREATE TABLE IF NOT EXISTS "{table_name}" (\n'
+        + ",\n".join(column_defs)
+        + "\n)"
+    )
+
+
+# -----------------------
+# CSV Import
+# -----------------------
+
+
+def import_csv_helper(conn, table_name: str, csv_path: Path):
+    """
+    Import CSV into database using given cursor.
+    Column types inferred automatically.
+
+    :param conn: SQLite database connection to use.
+    :param table_name: Table to import the CSV into.
+    :param csv_path: Path like path of the CSV file to import.
+    """
+    if not csv_path.exists():
+        raise FileNotFoundError(f"CSV file not found: {csv_path}")
+
+    # Read CSV rows
+    with csv_path.open(newline="", encoding="utf-8") as f:
+        reader = list(DictReader(f))
+        if not reader:
+            raise ValueError("CSV file is empty.")
+        inferred_cols = infer_columns_from_rows(reader)
+
+        cursor = conn.cursor()
+        # Drop existing table
+        cursor.execute(f'DROP TABLE IF EXISTS "{table_name}";')
+
+        # Create table
+        create_sql = _create_table_from_columns(table_name, inferred_cols)
+        cursor.execute(create_sql)
+
+        # Insert rows
+        cols = list(reader[0].keys())
+        norm_map = {c: _normalize(c) for c in cols}
+        colnames = ",".join(f'"{norm_map[c]}"' for c in cols)
+        placeholders = ",".join("?" for _ in cols)
+        insert_sql = f'INSERT INTO "{table_name}" ({colnames}) VALUES ({placeholders})'
+
+        for row in reader:
+            values = [row[c] if row[c] != "" else None for c in cols]
+            cursor.execute(insert_sql, values)
+
+    cursor.close()
+    conn.commit()