memberjojo 2.0__py3-none-any.whl → 2.2__py3-none-any.whl

memberjojo/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.0'
-__version_tuple__ = version_tuple = (2, 0)
+__version__ = version = '2.2'
+__version_tuple__ = version_tuple = (2, 2)
 
 __commit_id__ = commit_id = None

memberjojo/mojo_common.py

@@ -50,7 +50,7 @@ class MojoSkel:
         print(f"Encrypted database {self.db_path} loaded securely.")
 
         # After table exists (or after import), build the dataclass
-        if self.table_exists(table_name):
+        if self.table_exists():
             self.row_class = self._build_dataclass_from_table()
         else:
             self.row_class = None
@@ -122,20 +122,50 @@ class MojoSkel:
 
     def import_csv(self, csv_path: Path):
         """
-        import the passed CSV into the sqlite database
+        Import the passed CSV into the encrypted sqlite database.
+        If a previous table exists, generate a diff using
+        mojo_loader.diff_cipher_tables().
 
         :param csv_path: Path like path of csv file.
         """
+        old_table = f"{self.table_name}_old"
+        had_existing = self.table_exists()
+
+        # 1. Preserve existing table
+        if had_existing:
+            self.conn.execute(f"ALTER TABLE {self.table_name} RENAME TO {old_table}")
+
+        # 2. Import CSV as new table
         mojo_loader.import_csv_helper(self.conn, self.table_name, csv_path)
         self.row_class = self._build_dataclass_from_table()
 
+        if not had_existing:
+            return
+
+        try:
+            # 3. Diff old vs new (SQLCipher → sqlite3 → dataclasses)
+            diff_rows = mojo_loader.diff_cipher_tables(
+                self.conn,
+                new_table=self.table_name,
+                old_table=old_table,
+            )
+
+            if diff_rows:
+                for diff in diff_rows:
+                    # diff is a DiffRow dataclass
+                    print(diff.diff_type, diff.preview)
+
+        finally:
+            # 4. Cleanup old table (always)
+            self.conn.execute(f"DROP TABLE {old_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):
+        if self.table_exists():
             self.cursor.execute(f'SELECT * FROM "{self.table_name}" LIMIT ?', (limit,))
             rows = self.cursor.fetchall()
 
@@ -150,7 +180,7 @@ class MojoSkel:
         """
         :return: count of the number of rows in the table, or 0 if no table.
         """
-        if self.table_exists(self.table_name):
+        if self.table_exists():
             self.cursor.execute(f'SELECT COUNT(*) FROM "{self.table_name}"')
             result = self.cursor.fetchone()
             return result[0] if result else 0
@@ -216,12 +246,12 @@ class MojoSkel:
         self.cursor.execute(base_query, values)
         return self.cursor.fetchall()
 
-    def table_exists(self, table_name: str) -> bool:
+    def table_exists(self) -> 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,),
+            (self.table_name,),
         )
         return self.cursor.fetchone() is not None

memberjojo/mojo_loader.py

@@ -3,10 +3,28 @@
 Helper module for importing a CSV into a SQLite database.
 """
 
+from collections import defaultdict, Counter
 from csv import DictReader
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Any, Tuple
+
 import re
-from collections import defaultdict, Counter
+import sqlite3 as sqlite3_builtin
+
+
+@dataclass(frozen=True)
+class DiffRow:
+    """
+    Represents a single diff result.
+
+    - diff_type: 'added' | 'deleted' | 'changed'
+    - preview: tuple of values, with preview[0] == key
+    """
+
+    diff_type: str
+    preview: Tuple[Any, ...]
+
 
 # -----------------------
 # Normalization & Type Guessing
@@ -29,6 +47,10 @@ def _normalize(name: str) -> str:
 def _guess_type(value: any) -> str:
     """
     Guess SQLite data type of a CSV value: 'INTEGER', 'REAL', or 'TEXT'.
+
+    :param value: entry from sqlite database to guess the type of
+
+    :return: string of the type, TEXT, INTEGER, REAL
     """
     if value is None:
         return "TEXT"
@@ -51,6 +73,10 @@ def infer_columns_from_rows(rows: list[dict]) -> dict[str, str]:
     """
     Infer column types from CSV rows.
     Returns mapping: normalized column name -> SQLite type.
+
+    :param rows: list of rows to use for inference
+
+    :return: dict of name, type for columns
     """
     type_counters = defaultdict(Counter)
 
@@ -85,11 +111,18 @@ def _create_table_from_columns(table_name: str, columns: dict[str, str]) -> str:
 
     :return: SQL commands to create the table.
     """
-    column_defs = [f'"{col}" {col_type}' for col, col_type in columns.items()]
+    col_defs = []
+    first = True
+
+    for col, col_type in columns.items():
+        if first:
+            col_defs.append(f'"{col}" {col_type} PRIMARY KEY')
+            first = False
+        else:
+            col_defs.append(f'"{col}" {col_type}')
+
     return (
-        f'CREATE TABLE IF NOT EXISTS "{table_name}" (\n'
-        + ",\n".join(column_defs)
-        + "\n)"
+        f'CREATE TABLE IF NOT EXISTS "{table_name}" (\n' + ",\n".join(col_defs) + "\n)"
     )
 
 
@@ -138,3 +171,165 @@ def import_csv_helper(conn, table_name: str, csv_path: Path):
 
     cursor.close()
     conn.commit()
+
+
+# -----------------------
+# diff generation
+# -----------------------
+
+
+def _diffrow_from_sql_row(row: sqlite3_builtin.Row) -> DiffRow:
+    """
+    Convert a sqlite3.Row from generate_sql_diff into DiffRow.
+    Row shape:
+        (diff_type, col1, col2, col3, ...)
+
+    :param row: Row from sqlite3 database to create a dataclass entry from
+
+    :return: A dataclass of the row
+    """
+    return DiffRow(
+        diff_type=row[0],
+        preview=tuple(row[1:]),
+    )
+
+
+def diff_cipher_tables(
+    cipher_conn,
+    *,
+    new_table: str,
+    old_table: str,
+) -> list[DiffRow]:
+    """
+    Copy old and new tables from SQLCipher into a single
+    in-memory sqlite3 database and diff them there.
+
+    :param cipher_conn: sqlite connection to the encrypted db
+    :param new_table: name of the new table for comparison
+    :param old_table: name of the old table for comparison
+
+    :return: a list of DiffRow entries of the changed rows
+    """
+
+    plain = sqlite3_builtin.connect(":memory:")
+    plain.row_factory = sqlite3_builtin.Row
+
+    try:
+        for table in (old_table, new_table):
+            # 1. Clone schema using SQLite itself
+            schema_sql = cipher_conn.execute(
+                """
+                SELECT sql
+                FROM sqlite_master
+                WHERE type='table' AND name=?
+                """,
+                (table,),
+            ).fetchone()
+
+            if schema_sql is None:
+                raise RuntimeError(f"Table {table!r} not found in cipher DB")
+
+            plain.execute(schema_sql[0])
+
+            # 2. Copy data
+            rows = cipher_conn.execute(f"SELECT * FROM {table}")
+            cols = [d[0] for d in rows.description]
+
+            col_list = ", ".join(cols)
+            placeholders = ", ".join("?" for _ in cols)
+
+            plain.executemany(
+                f"INSERT INTO {table} ({col_list}) VALUES ({placeholders})",
+                rows.fetchall(),
+            )
+
+        # 3. Run sqlite-only diff
+        rows = _generate_sql_diff(
+            plain,
+            new_table=new_table,
+            old_table=old_table,
+        )
+
+        return [_diffrow_from_sql_row(r) for r in rows]
+
+    finally:
+        plain.close()
+
+
+def _generate_sql_diff(
+    conn: sqlite3_builtin.Connection,
+    *,
+    new_table: str,
+    old_table: str,
+) -> list[sqlite3_builtin.Row]:
+    """
+    Generate a diff between two tables using standard SQLite features.
+
+    - The FIRST column is the primary key.
+    - Returned row shape:
+            (diff_type, preview_col1, preview_col2, preview_col3, ...)
+
+    :param conn: sqlite connection to the db, using python builtin sqlite
+    :param new_table: name of the new table to use for comparison
+    :param old_table: name of the old table to use for comparison
+
+    :return: list of sqlite rows that are changed
+    """
+
+    # 1. Introspect schema (order-preserving)
+    cols_info = conn.execute(f"PRAGMA table_info({new_table})").fetchall()
+
+    if not cols_info:
+        raise RuntimeError(f"Table {new_table!r} has no columns")
+
+    cols = [row[1] for row in cols_info]
+
+    key = cols[0]
+    non_key_cols = cols[1:]
+
+    # 2. Preview columns (key first, limit for readability)
+    preview_cols = [key] + non_key_cols[:5]
+
+    new_preview = ", ".join(f"n.{c}" for c in preview_cols)
+    old_preview = ", ".join(f"o.{c}" for c in preview_cols)
+
+    # 3. Row-value comparison (NULL-safe)
+    if non_key_cols:
+        changed_predicate = (
+            f"({', '.join(f'n.{c}' for c in non_key_cols)}) "
+            f"IS NOT "
+            f"({', '.join(f'o.{c}' for c in non_key_cols)})"
+        )
+    else:
+        # Key-only table
+        changed_predicate = "0"
+
+    sql = f"""
+        WITH
+            added AS (
+                SELECT 'added' AS diff_type, {new_preview}
+                FROM {new_table} n
+                LEFT JOIN {old_table} o USING ({key})
+                WHERE o.{key} IS NULL
+            ),
+            deleted AS (
+                SELECT 'deleted' AS diff_type, {old_preview}
+                FROM {old_table} o
+                LEFT JOIN {new_table} n USING ({key})
+                WHERE n.{key} IS NULL
+            ),
+            changed AS (
+                SELECT 'changed' AS diff_type, {new_preview}
+                FROM {new_table} n
+                JOIN {old_table} o USING ({key})
+                WHERE {changed_predicate}
+            )
+        SELECT * FROM added
+        UNION ALL
+        SELECT * FROM deleted
+        UNION ALL
+        SELECT * FROM changed
+        ORDER BY {key};
+        """
+
+    return list(conn.execute(sql))

memberjojo/mojo_member.py

@@ -124,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.

{memberjojo-2.0.dist-info → memberjojo-2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memberjojo
-Version: 2.0
+Version: 2.2
 Summary: memberjojo - tools for working with members.
 Author-email: Duncan Bellamy <dunk@denkimushi.com>
 Requires-Python: >=3.8
@@ -32,17 +32,15 @@ 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 dropped before import, so you can
-just import the latest download and the local database is updated.\
+just import the latest download and the local database is updated.
 
 ---
 
 ## Installation
 
-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)\
+(The sqlcipher bindings are compiled by pip so the `C_INCLUDE_PATH` and
+`LIBRARY_PATH` are needed for the `libsqlcipher` files to be found)
 
 ```bash
 brew install sqlcipher

memberjojo-2.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+memberjojo/__init__.py,sha256=JGhIJ1HGbzrwzF4HsopOdP4eweLjUmFjbIDvMbk1MKI,291
+memberjojo/_version.py,sha256=_Nk5-Ctb0Jdj1fjUXI6x5dxb-FwdE56jfaBDPomGv_A,699
+memberjojo/mojo_common.py,sha256=DqJ3NKq1Lrcv8NejJFR3ZHlwZifTjqIZv6Vp0R8yOQQ,8340
+memberjojo/mojo_loader.py,sha256=pKqp7QiirThYd6gIy1LQ48GbV2DVFL0yZSLUWxuTLa0,9232
+memberjojo/mojo_member.py,sha256=3UeBIVtSXBCUpvuGN9fIJ0zgXu6vXhs4wFDHeDnOG0o,8078
+memberjojo/mojo_transaction.py,sha256=EuP_iu5R5HHCkr6PaJdWG0BP-XFMAjl-YPuCDVnKaRE,916
+memberjojo-2.2.dist-info/licenses/LICENSE,sha256=eaTLEca5OoRQ9r8GlC6Rwa1BormM3q-ppDWLFFxhQxI,1071
+memberjojo-2.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+memberjojo-2.2.dist-info/METADATA,sha256=p8d0fTLtfNk5Hir3CRwjBl5WhSYrZL4UpiokpsE0Wsk,3593
+memberjojo-2.2.dist-info/RECORD,,

memberjojo/config.py

@@ -1,5 +0,0 @@
-"""
-Default encoding for importing CSV files
-"""
-
-CSV_ENCODING = "UTF-8"

memberjojo-2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-memberjojo/__init__.py,sha256=JGhIJ1HGbzrwzF4HsopOdP4eweLjUmFjbIDvMbk1MKI,291
-memberjojo/_version.py,sha256=BQP3Alj0qj-vHGLR2CI-B53HBhY5UAffEPyInuYZ0jU,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=1Tei14y3opJ4To0KerUwJ7_kidFB87jKWZ7KjDN3B4k,8088
-memberjojo/mojo_transaction.py,sha256=EuP_iu5R5HHCkr6PaJdWG0BP-XFMAjl-YPuCDVnKaRE,916
-memberjojo-2.0.dist-info/licenses/LICENSE,sha256=eaTLEca5OoRQ9r8GlC6Rwa1BormM3q-ppDWLFFxhQxI,1071
-memberjojo-2.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-memberjojo-2.0.dist-info/METADATA,sha256=rGQLFERi8EpqH5oowAatO5xIOtaNc987BBOH4DY0zc4,3602
-memberjojo-2.0.dist-info/RECORD,,