memberjojo 1.2__py3-none-any.whl → 2.1__py3-none-any.whl

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/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.2'
-__version_tuple__ = version_tuple = (1, 2)
+__version__ = version = '2.1'
+__version_tuple__ = version_tuple = (2, 1)
 
 __commit_id__ = commit_id = None

memberjojo/mojo_common.py

@@ -5,7 +5,16 @@ This module provides a common base class (`MojoSkel`) for other `memberjojo` mod
 It includes helper methods for working with SQLite databases.
 """
 
-import sqlite3
+# 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:
@@ -14,7 +23,7 @@ class MojoSkel:
     for querying tables.
     """
 
-    def __init__(self, db_path: str, table_name: str):
+    def __init__(self, db_path: str, db_key: str, table_name: str):
         """
         Initialize the MojoSkel class.
 
@@ -22,13 +31,103 @@ class MojoSkel:
         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.conn = sqlite3.connect(db_path)
+        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()
-        self.table_name = table_name
+
+        # 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):
         """
@@ -36,10 +135,11 @@ class MojoSkel:
 
         :param limit: (optional) Number of rows to display. Defaults to 2.
         """
-        self.cursor.execute(f'SELECT * FROM "{self.table_name}" LIMIT ?', (limit,))
-        rows = self.cursor.fetchall()
+        if self.table_exists(self.table_name):
+            self.cursor.execute(f'SELECT * FROM "{self.table_name}" LIMIT ?', (limit,))
+            rows = self.cursor.fetchall()
 
-        if not rows:
+        else:
             print("(No data)")
             return
 
@@ -48,8 +148,80 @@ class MojoSkel:
 
     def count(self) -> int:
         """
-        Returns count of the number of rows in the table.
+        :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(f'SELECT COUNT(*) FROM "{self.table_name}"')
-        result = self.cursor.fetchone()
-        return result[0] if result else 0
+        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/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()

memberjojo/mojo_member.py

@@ -5,37 +5,11 @@ This module loads data from a `members.csv` file downloaded from Membermojo,
 stores it in SQLite, and provides helper functions for member lookups.
 """
 
-from csv import DictReader
-from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
-import sqlite3
-from .config import CSV_ENCODING  # import encoding from config.py
 from .mojo_common import MojoSkel
 
 
-@dataclass
-class MemberData:
-    """
-    A dataclass to represent a single member's data for database operations.
-
-    Attributes:
-        member_num (int): Unique member number (primary key).
-        title (str): Title (e.g., Mr, Mrs, Ms).
-        first_name (str): Member's first name.
-        last_name (str): Member's last name.
-        membermojo_id (int): Unique Membermojo ID.
-        short_url (str): Short URL to Membermojo profile.
-    """
-
-    member_num: int
-    title: str
-    first_name: str
-    last_name: str
-    membermojo_id: int
-    short_url: str
-
-
 class Member(MojoSkel):
     """
     Subclass of MojoSkel providing member-specific database functions.
@@ -45,53 +19,19 @@ class Member(MojoSkel):
 
     :param member_db_path (Path): Path to the SQLite database file.
     :param table_name (str): (optional) Table name to use. Defaults to "members".
+    :param db_key: (optional) key to unlock the encrypted sqlite database, unencrypted if unset.
     """
 
-    def __init__(self, member_db_path: Path, table_name: str = "members"):
+    def __init__(
+        self,
+        member_db_path: Path,
+        db_key: str,
+        table_name: str = "members",
+    ):
         """
         Initialize the Member database handler.
         """
-        super().__init__(member_db_path, table_name)
-
-    def __iter__(self):
-        """
-        Allow iterating over the class, by outputing all members.
-        """
-        sql = (
-            f"SELECT member_number, "
-            f"title, "
-            f"first_name, "
-            f"last_name, "
-            f"membermojo_id, "
-            f"short_url "
-            f'FROM "{self.table_name}"'
-        )
-        self.cursor.execute(sql)
-        rows = self.cursor.fetchall()
-        for row in rows:
-            yield MemberData(*row)
-
-    def _create_tables(self):
-        """
-        Create the members table in the database if it doesn't exist.
-
-        The table includes member number, title, first/last names,
-        Membermojo ID, and a short profile URL.
-        """
-        sql_statements = [
-            f"""CREATE TABLE IF NOT EXISTS "{self.table_name}" (
-                member_number INTEGER PRIMARY KEY,
-                title TEXT NOT NULL CHECK(title IN ('Dr', 'Mr', 'Mrs', 'Miss', 'Ms')),
-                first_name TEXT NOT NULL,
-                last_name TEXT NOT NULL,
-                membermojo_id INTEGER UNIQUE NOT NULL,
-                short_url TEXT NOT NULL
-            );"""
-        ]
-
-        for statement in sql_statements:
-            self.cursor.execute(statement)
-        self.conn.commit()
+        super().__init__(member_db_path, db_key, table_name)
 
     def get_number_first_last(
         self, first_name: str, last_name: str, found_error: bool = False
@@ -108,9 +48,9 @@ class Member(MojoSkel):
         :raises ValueError: If not found and `found_error` is True.
         """
         sql = f"""
-            SELECT member_number
+            SELECT "member_number"
             FROM "{self.table_name}"
-            WHERE LOWER(first_name) = LOWER(?) AND LOWER(last_name) = LOWER(?)
+            WHERE LOWER("first_name") = LOWER(?) AND LOWER("last_name") = LOWER(?)
         """
         self.cursor.execute(sql, (first_name, last_name))
         result = self.cursor.fetchone()
@@ -150,10 +90,10 @@ class Member(MojoSkel):
         :return: Name on membermojo or None
         """
         sql = f"""
-                SELECT first_name, last_name
+                SELECT "first_name", "last_name"
                 FROM "{self.table_name}"
-                WHERE LOWER(first_name) = LOWER(?)
-                    AND LOWER(last_name)  = LOWER(?)
+                WHERE LOWER("first_name") = LOWER(?)
+                    AND LOWER("last_name")  = LOWER(?)
         """
         self.cursor.execute(sql, (first_name, last_name))
         row = self.cursor.fetchone()
@@ -169,10 +109,10 @@ class Member(MojoSkel):
         :return: Name on membermojo or None
         """
         sql = f"""
-                SELECT first_name, last_name
+                SELECT "first_name", "last_name"
                 FROM "{self.table_name}"
-                WHERE LOWER(first_name) LIKE LOWER(?) || '%'
-                    AND LOWER(last_name) = LOWER(?)
+                WHERE LOWER("first_name") LIKE LOWER(?) || '%'
+                    AND LOWER("last_name") = LOWER(?)
                 LIMIT 1
         """
         self.cursor.execute(sql, (letter, last_name))
@@ -184,11 +124,14 @@ class Member(MojoSkel):
     ) -> Optional[tuple]:
         """
         Resolve a member name from a free-text full name.
-        Search order:
-            1. first + last
-            2. middle + last (if three parts)
-            3. initial 1st letter + last
-            4. initial 2nd letter + last (for two-letter initials)
+
+        **Search order**
+
+        1. first + last
+        2. middle + last (if three parts)
+        3. initial 1st letter + last
+        4. initial 2nd letter + last (for two-letter initials)
+
         Returns (first_name, last_name) or None.
 
         :param full_name: Full name of the member to find.
@@ -271,9 +214,9 @@ class Member(MojoSkel):
         :return: Full name as tuple, or None if not found.
         """
         sql = f"""
-            SELECT first_name, last_name
+            SELECT "first_name", "last_name"
             FROM "{self.table_name}"
-            WHERE member_number = ?
+            WHERE "member_number" = ?
             """
         self.cursor.execute(sql, (member_number,))
         result = self.cursor.fetchone()
@@ -295,61 +238,3 @@ class Member(MojoSkel):
             first_name, last_name = result
             return f"{first_name} {last_name}"
         return None
-
-    def _add(self, member: MemberData):
-        """
-        Insert a member into the database if not already present.
-
-        :param member: The member to add.
-        """
-        sql = f"""INSERT OR ABORT INTO "{self.table_name}"
-            (member_number, title, first_name, last_name, membermojo_id, short_url)
-            VALUES (?, ?, ?, ?, ?, ?)"""
-
-        try:
-            self.cursor.execute(
-                sql,
-                (
-                    member.member_num,
-                    member.title,
-                    member.first_name,
-                    member.last_name,
-                    member.membermojo_id,
-                    member.short_url,
-                ),
-            )
-            self.conn.commit()
-            print(
-                f"Created user {member.member_num}: {member.first_name} {member.last_name}"
-            )
-        except sqlite3.IntegrityError:
-            pass
-
-    def import_csv(self, csv_path: Path):
-        """
-        Load members from a Membermojo CSV file and insert into the database.
-
-        :param csv_path: Path to the CSV file.
-
-        Notes:
-            Only adds members not already in the database (INSERT OR ABORT).
-        """
-        print(f"Using SQLite database version {sqlite3.sqlite_version}")
-        self._create_tables()
-
-        try:
-            with csv_path.open(newline="", encoding=CSV_ENCODING) as csvfile:
-                mojo_reader = DictReader(csvfile)
-
-                for row in mojo_reader:
-                    member = MemberData(
-                        member_num=int(row["Member number"]),
-                        title=row["Title"].strip(),
-                        first_name=row["First name"].strip(),
-                        last_name=row["Last name"].strip(),
-                        membermojo_id=int(row["membermojo ID"]),
-                        short_url=row["Short URL"].strip(),
-                    )
-                    self._add(member)
-        except FileNotFoundError:
-            print(f"CSV file not found: {csv_path}")

memberjojo/mojo_transaction.py

@@ -5,13 +5,6 @@ Provides automatic column type inference, robust CSV importing, and
 helper methods for querying the database.
 """
 
-from collections import Counter, defaultdict
-from csv import DictReader
-from pathlib import Path
-from sqlite3 import IntegrityError, OperationalError, DatabaseError
-from decimal import Decimal
-
-from .config import CSV_ENCODING  # import encoding from config.py
 from .mojo_common import MojoSkel
 
 
@@ -24,219 +17,16 @@ class Transaction(MojoSkel):
 
     :param payment_db_path: Path to the SQLite database.
     :param table_name: (optional) Name of the table. Defaults to "payments".
+    :param db_key: (optional) key to unlock the encrypted sqlite database, unencrypted if unset.
     """
 
-    def __init__(self, payment_db_path: str, table_name: str = "payments"):
+    def __init__(
+        self,
+        payment_db_path: str,
+        db_key: str,
+        table_name: str = "payments",
+    ):
         """
         Initialize the Transaction object.
         """
-        super().__init__(payment_db_path, table_name)
-        self.columns = {}
-
-    def _guess_type(self, value: any) -> str:
-        """
-        Guess the SQLite data type of a CSV field value.
-
-        :param value: The value from a CSV field.
-
-        :return: One of '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(self, rows: list[dict]):
-        """
-        Infer SQLite column types based on sample CSV data.
-
-        :param rows: Sample rows from CSV to analyze.
-        """
-        type_counters = defaultdict(Counter)
-
-        for row in rows:
-            for key, value in row.items():
-                guessed_type = self._guess_type(value)
-                type_counters[key][guessed_type] += 1
-
-        self.columns = {}
-        for col, counter in type_counters.items():
-            if counter["TEXT"] == 0:
-                if counter["REAL"] > 0:
-                    self.columns[col] = "REAL"
-                else:
-                    self.columns[col] = "INTEGER"
-            else:
-                self.columns[col] = "TEXT"
-
-        print("Inferred columns:", self.columns)
-
-    def _create_tables(self, table: str, primary_col: str):
-        """
-        Create the table if it doesn't exist, using inferred schema.
-
-        :param table: Table name.
-        :param primary_col: Column to use as primary key, or None for default.
-        """
-        col_names = list(self.columns.keys())
-        if primary_col is None:
-            primary_col = col_names[0]
-        elif primary_col not in self.columns:
-            raise ValueError(f"Primary key column '{primary_col}' not found in CSV.")
-
-        cols_def = ", ".join(
-            f'"{col}" {col_type}{" PRIMARY KEY" if col == primary_col else ""}'
-            for col, col_type in self.columns.items()
-        )
-
-        self.cursor.execute(f'CREATE TABLE IF NOT EXISTS "{table}" ({cols_def})')
-        self.conn.commit()
-
-    def _parse_row_values(self, row: dict, column_types: dict) -> tuple:
-        """
-        Convert CSV row string values to types suitable for SQLite.
-
-        :param row: A dictionary from the CSV row.
-        :param column_types: Mapping of column names to SQLite types.
-
-        :return: Parsed values.
-        """
-        values = []
-        for col, col_type in column_types.items():
-            val = row.get(col, "")
-            if val is None or val.strip() == "":
-                values.append(None)
-            elif col_type == "REAL":
-                values.append(float(val))
-            elif col_type == "INTEGER":
-                values.append(int(val))
-            else:
-                values.append(val)
-        return tuple(values)
-
-    def import_csv(self, csv_path: Path, pk_column: str = None, sample_size: int = 100):
-        """
-        Import a completed_payments.csv file into SQLite.
-
-        Infers column types and logs failed rows. Creates the table if needed.
-
-        :param csv_path: Path to the CSV file.
-        :param pk_column: (optional) Primary key column name. Defaults to the first column.
-        :param sample_size: (optional) Number of rows to sample for type inference. Defaults to 100.
-
-        :raises ValueError: If the CSV is empty or contains failed insertions.
-        """
-        try:
-            # First pass: infer schema from sample
-            with csv_path.open(newline="", encoding=CSV_ENCODING) as csvfile:
-                reader = DictReader(csvfile)
-                sample_rows = [row for _, row in zip(range(sample_size), reader)]
-                if not sample_rows:
-                    raise ValueError("CSV file is empty.")
-
-                # Only infer columns if not already set (i.e., first import)
-                if not self.columns:
-                    self._infer_columns_from_rows(sample_rows)
-
-        except FileNotFoundError:
-            print(f"CSV file not found: {csv_path}")
-            return
-
-        # Create table
-        self._create_tables(self.table_name, pk_column)
-
-        # Count rows before import
-        count_before = self.count()
-
-        # Second pass: insert all rows
-        failed_rows = []
-        with csv_path.open(newline="", encoding=CSV_ENCODING) as csvfile:
-            reader = DictReader(csvfile)
-            column_list = ", ".join(f'"{col}"' for col in self.columns)
-            placeholders = ", ".join(["?"] * len(self.columns))
-            insert_stmt = f'INSERT OR IGNORE INTO "{self.table_name}" ({column_list}) \
-                VALUES ({placeholders})'
-
-            for row in reader:
-                try:
-                    self.cursor.execute(
-                        insert_stmt, self._parse_row_values(row, self.columns)
-                    )
-
-                except (
-                    IntegrityError,
-                    OperationalError,
-                    DatabaseError,
-                    ValueError,
-                ) as e:
-                    failed_rows.append((row.copy(), str(e)))
-
-            self.conn.commit()
-
-        print(
-            f"Inserted {self.count() - count_before} new rows into '{self.table_name}'."
-        )
-
-        if failed_rows:
-            print(f"{len(failed_rows)} rows failed to insert:")
-            for row, error in failed_rows[:5]:
-                print(f"Failed: {error} | Data: {row}")
-            if len(failed_rows) > 5:
-                print(f"... and {len(failed_rows) - 5} more")
-            raise ValueError(f"Failed to import: {csv_path}")
-
-    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) -> dict:
-        """
-        Retrieve the first row matching multiple column = value pairs.
-
-        :param match_dict: Dictionary of column names and values to match.
-
-        :return: The first matching row, or None if not found.
-        """
-        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
-                )
-
-        query = f'SELECT * FROM "{self.table_name}" WHERE {" AND ".join(conditions)} LIMIT 1'
-        self.cursor.execute(query, values)
-        return self.cursor.fetchone()
+        super().__init__(payment_db_path, db_key, table_name)

{memberjojo-1.2.dist-info → memberjojo-2.1.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: memberjojo
-Version: 1.2
+Version: 2.1
 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-2.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+memberjojo/__init__.py,sha256=JGhIJ1HGbzrwzF4HsopOdP4eweLjUmFjbIDvMbk1MKI,291
+memberjojo/_version.py,sha256=sdXMKvhafMmgXhpEPosw8Vx1-ID_v-Fo2LNHMrsKPJc,699
+memberjojo/config.py,sha256=_R3uWh5bfMCfZatXLm49pDXet-tipoPbUO7FUeMu2OI,73
+memberjojo/mojo_common.py,sha256=uisTDjc7SCcTIecF35issytUzD8cHn3Tx7YbDZkp64E,7402
+memberjojo/mojo_loader.py,sha256=PZRrdjCCqatrGbqyqPoI5Pg6IWmeVduqyE8zV9GwKlg,3935
+memberjojo/mojo_member.py,sha256=3UeBIVtSXBCUpvuGN9fIJ0zgXu6vXhs4wFDHeDnOG0o,8078
+memberjojo/mojo_transaction.py,sha256=EuP_iu5R5HHCkr6PaJdWG0BP-XFMAjl-YPuCDVnKaRE,916
+memberjojo-2.1.dist-info/licenses/LICENSE,sha256=eaTLEca5OoRQ9r8GlC6Rwa1BormM3q-ppDWLFFxhQxI,1071
+memberjojo-2.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+memberjojo-2.1.dist-info/METADATA,sha256=3acNsTk91IdcxAHJ0-a5mjS74VjittHIcWD17gY3H7g,3602
+memberjojo-2.1.dist-info/RECORD,,

memberjojo-1.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-memberjojo/__init__.py,sha256=KfW3YTaJkEfdjr1Yf9Lf1jBrBErvCbZ7p-1Y6qzEIOY,303
-memberjojo/_version.py,sha256=HQKKxCSMqVTOOMMdZI6WQjmRkHgmuUGY2FWf9ey1h9Y,699
-memberjojo/config.py,sha256=_R3uWh5bfMCfZatXLm49pDXet-tipoPbUO7FUeMu2OI,73
-memberjojo/mojo_common.py,sha256=hSMNggC1BOTLOeRQlv4LOC7gqfM0GMRdoHHT5PnuakA,1597
-memberjojo/mojo_member.py,sha256=mlv847JW0KaeKJ1MtA_x2TlgUr2q6Pie_LiCyZYRniM,11929
-memberjojo/mojo_transaction.py,sha256=772QU3O2xQAzgddRRBqf4UTjXwxKoSZTbHndvMSHcMM,8379
-memberjojo-1.2.dist-info/licenses/LICENSE,sha256=eaTLEca5OoRQ9r8GlC6Rwa1BormM3q-ppDWLFFxhQxI,1071
-memberjojo-1.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-memberjojo-1.2.dist-info/METADATA,sha256=1__DegGgyFuh4CXIrBEdShdhTLOsZ_Ls-N8AEXI_xoo,3177
-memberjojo-1.2.dist-info/RECORD,,