memberjojo 2.1__tar.gz → 2.2__tar.gz

{memberjojo-2.1 → memberjojo-2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memberjojo
-Version: 2.1
+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.1 → memberjojo-2.2}/README.md

@@ -8,17 +8,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.1 → memberjojo-2.2}/src/memberjojo/_version.py

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

{memberjojo-2.1 → memberjojo-2.2}/src/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-2.2/src/memberjojo/mojo_loader.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""
+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
+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
+# -----------------------
+
+
+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'.
+
+    :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"
+    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.
+
+    :param rows: list of rows to use for inference
+
+    :return: dict of name, type for columns
+    """
+    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.
+    """
+    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(col_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()
+
+
+# -----------------------
+# 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-2.2/tests/test_mojo_import_diff.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+CSV diff tests for the Member class
+"""
+
+import csv
+from pathlib import Path
+
+from memberjojo.mojo_common import MojoSkel
+
+
+def write_csv(path: Path, rows: list[dict]):
+    """Utility: write CSV with DictWriter."""
+    with path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=rows[0].keys())
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def test_import_new_csv_generates_diff(tmp_path, capsys):
+    """
+    Test importing one CSV, then importing a changed CSV,
+    and verify that the diff prints correctly.
+    """
+
+    # -----------------------
+    # 1. Original CSV
+    # -----------------------
+    csv1 = tmp_path / "members1.csv"
+    original_rows = [
+        {"id": "1", "name": "Alice", "age": "30"},
+        {"id": "2", "name": "Bob", "age": "40"},
+    ]
+    write_csv(csv1, original_rows)
+
+    # Create DB
+    db_path = tmp_path / "test_members.db"
+    password = "Needs a Password"
+
+    # Load initial CSV
+    m = MojoSkel(str(db_path), password, "members")
+    m.import_csv(csv1)
+
+    assert m.count() == 2
+
+    # -----------------------
+    # 2. Modified CSV with one added, one deleted, one changed
+    # -----------------------
+    csv2 = tmp_path / "members2.csv"
+    updated_rows = [
+        {"id": "1", "name": "Alice", "age": "31"},  # changed: age 30 -> 31
+        {"id": "3", "name": "Cara", "age": "22"},  # added
+    ]
+    write_csv(csv2, updated_rows)
+
+    # Import second CSV → should trigger rename + diff + drop old table
+    m.import_csv(csv2)
+
+    # Capture printed diff output
+    captured = capsys.readouterr().out
+
+    # -----------------------
+    # 3. Check diff lines
+    # -----------------------
+    # We expect:
+    # - rowid 1: changed (age differs)
+    # - rowid 2: deleted (Bob missing)
+    # - rowid 3: added   (Cara new)
+    #
+    # Diff output rows look like:
+    #   (1, 'changed')
+    #   (2, 'deleted')
+    #   (3, 'added')
+
+    assert "changed" in captured
+    assert "deleted" in captured
+    assert "added" in captured
+
+    # Count rows after second import
+    assert m.count() == 2
+
+    # Ensure old table is gone
+    cur = m.conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='members_old'"
+    )
+    assert cur.fetchone() is None

memberjojo-2.2/tests/test_mojo_members_iter.py

@@ -0,0 +1,140 @@
+"""
+Iteration tests for the Member class
+"""
+
+import csv
+import pytest
+from memberjojo import Member
+
+
+# conftest.py or at top of test file
+SAMPLE_MEMBERS = [
+    {
+        "Member number": "11",
+        "Title": "Mr",
+        "First name": "Johnny",
+        "Last name": "Doe",
+        "membermojo ID": "8001",
+        "Short URL": "http://short.url/johnny",
+    },
+    {
+        "Member number": "12",
+        "Title": "Ms",
+        "First name": "Janice",
+        "Last name": "Smith",
+        "membermojo ID": "8002",
+        "Short URL": "http://short.url/janice",
+    },
+]
+
+
+def test_member_iter(tmp_path):
+    """
+    Test for iterating over the member data.
+    """
+    # Prepare sample CSV data
+    sample_csv = tmp_path / "members.csv"
+
+    # Write CSV file
+    with sample_csv.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=SAMPLE_MEMBERS[0].keys())
+        writer.writeheader()
+        writer.writerows(SAMPLE_MEMBERS)
+
+    # Create DB path
+    db_path = tmp_path / "test_members.db"
+
+    # Instantiate Member and import CSV
+    members = Member(db_path, "Needs a Password")
+    members.import_csv(sample_csv)
+
+    # Collect members from iterator
+    iterated_members = list(members)
+
+    # Check that iteration yields correct number of members
+    assert len(iterated_members) == len(SAMPLE_MEMBERS)
+
+    # Check that fields match for first member
+    first = iterated_members[0]
+    assert isinstance(first, members.row_class)
+    assert first.member_number == int(SAMPLE_MEMBERS[0]["Member number"])
+    assert first.title == SAMPLE_MEMBERS[0]["Title"]
+    assert first.first_name == SAMPLE_MEMBERS[0]["First name"]
+    assert first.last_name == SAMPLE_MEMBERS[0]["Last name"]
+    assert first.membermojo_id == int(SAMPLE_MEMBERS[0]["membermojo ID"])
+    assert first.short_url == SAMPLE_MEMBERS[0]["Short URL"]
+
+    # Check second member also matches
+    second = iterated_members[1]
+    assert second.first_name == SAMPLE_MEMBERS[1]["First name"]
+    assert second.last_name == SAMPLE_MEMBERS[1]["Last name"]
+
+
+def test_iter_without_loading(tmp_path):
+    """
+    Iterating a MojoSkel instance without loading a table
+    should raise RuntimeError.
+    """
+    db_path = tmp_path / "test.db"
+    m = Member(str(db_path), "dummy_password", "members")
+
+    with pytest.raises(RuntimeError, match="Table not loaded yet"):
+        # Attempting iteration without loading CSV
+        for _ in m:
+            pass
+
+
+def test_member_import_persist_and_reload(tmp_path):
+    """
+    Test importing a CSV, closing the DB, reopening it,
+    and verifying that the data matches exactly.
+    """
+
+    # ------------------------
+    # 1. Prepare CSV test data
+    # ------------------------
+    sample_csv = tmp_path / "members.csv"
+
+    with sample_csv.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=SAMPLE_MEMBERS[0].keys())
+        writer.writeheader()
+        writer.writerows(SAMPLE_MEMBERS)
+
+    # ----------------------
+    # 2. Import into database
+    # ----------------------
+    db_path = tmp_path / "test_members.db"
+    password = "Needs a Password"
+
+    members = Member(db_path, password)
+    members.import_csv(sample_csv)
+
+    # Capture original rows
+    rows_before = list(members)
+    assert len(rows_before) == len(SAMPLE_MEMBERS)
+
+    # Close DB
+    members.conn.close()
+
+    # ----------------------
+    # 3. Re-open the database
+    # ----------------------
+    members2 = Member(db_path, password)
+
+    rows_after = list(members2)
+    assert len(rows_after) == len(SAMPLE_MEMBERS)
+
+    # ---------------------------
+    # 4. Compare row by row fields
+    # ---------------------------
+    for before, after in zip(rows_before, rows_after):
+        # Same dataclass class?
+        assert (
+            before.__class__.__name__ == after.__class__.__name__
+        ), f"Dataclass names differ: {before.__class__} vs {after.__class__}"
+
+        # Compare all fields generically
+        for field in before.__dataclass_fields__:
+            assert getattr(before, field) == getattr(
+                after, field
+            ), f"Mismatch in field {field}"

memberjojo-2.1/src/memberjojo/config.py

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

memberjojo-2.1/src/memberjojo/mojo_loader.py

@@ -1,140 +0,0 @@
-#!/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-2.1/tests/test_mojo_members_iter.py

@@ -1,66 +0,0 @@
-"""
-Iteration tests for the Member class
-"""
-
-import csv
-from memberjojo import Member
-
-
-def test_member_iter(tmp_path):
-    """
-    Test for iterating over the member data.
-    """
-    # Prepare sample CSV data
-    sample_csv = tmp_path / "members.csv"
-    sample_data = [
-        {
-            "Member number": "11",
-            "Title": "Mr",
-            "First name": "Johnny",
-            "Last name": "Doe",
-            "membermojo ID": "8001",
-            "Short URL": "http://short.url/johnny",
-        },
-        {
-            "Member number": "12",
-            "Title": "Ms",
-            "First name": "Janice",
-            "Last name": "Smith",
-            "membermojo ID": "8002",
-            "Short URL": "http://short.url/janice",
-        },
-    ]
-
-    # Write CSV file
-    with sample_csv.open("w", newline="", encoding="utf-8") as f:
-        writer = csv.DictWriter(f, fieldnames=sample_data[0].keys())
-        writer.writeheader()
-        writer.writerows(sample_data)
-
-    # Create DB path
-    db_path = tmp_path / "test_members.db"
-
-    # Instantiate Member and import CSV
-    members = Member(db_path, "Needs a Password")
-    members.import_csv(sample_csv)
-
-    # Collect members from iterator
-    iterated_members = list(members)
-
-    # Check that iteration yields correct number of members
-    assert len(iterated_members) == len(sample_data)
-
-    # Check that fields match for first member
-    first = iterated_members[0]
-    assert isinstance(first, members.row_class)
-    assert first.member_number == int(sample_data[0]["Member number"])
-    assert first.title == sample_data[0]["Title"]
-    assert first.first_name == sample_data[0]["First name"]
-    assert first.last_name == sample_data[0]["Last name"]
-    assert first.membermojo_id == int(sample_data[0]["membermojo ID"])
-    assert first.short_url == sample_data[0]["Short URL"]
-
-    # Check second member also matches
-    second = iterated_members[1]
-    assert second.first_name == sample_data[1]["First name"]
-    assert second.last_name == sample_data[1]["Last name"]