memberjojo 2.3__tar.gz → 3.0__tar.gz

{memberjojo-2.3 → memberjojo-3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memberjojo
-Version: 2.3
+Version: 3.0
 Summary: memberjojo - tools for working with members.
 Author-email: Duncan Bellamy <dunk@denkimushi.com>
 Requires-Python: >=3.8

{memberjojo-2.3 → memberjojo-3.0}/src/memberjojo/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.3'
-__version_tuple__ = version_tuple = (2, 3)
+__version__ = version = '3.0'
+__version_tuple__ = version_tuple = (3, 0)
 
-__commit_id__ = commit_id = 'g9a43ccd5d'
+__commit_id__ = commit_id = 'g594a20473'

{memberjojo-2.3 → memberjojo-3.0}/src/memberjojo/mojo_common.py

@@ -187,39 +187,58 @@ class MojoSkel:
             # Cleanup old table (always)
             self.conn.execute(f"DROP TABLE {old_table}")
 
-    def download_csv(self, session: requests.Session, url: str):
+    def download_csv(self, session: requests.Session, url: str, merge: bool = False):
         """
         Download the CSV from url and import into the sqlite database
         If a previous table exists, generate a diff
 
         :param session: Requests session to use for download
         :param url: url of the csv to download
+        :param merge: (optional) If True, merge into existing table. Defaults to False.
         """
-        had_existing = self.table_exists()
-        old_table = self.rename_old_table(had_existing)
+        had_existing = False
+        old_table = ""
+
+        if not merge:
+            had_existing = self.table_exists()
+            old_table = self.rename_old_table(had_existing)
 
         # Download CSV as new table
-        mojo_loader.download_csv_helper(self.conn, self.table_name, url, session)
+        mojo_loader.download_csv_helper(
+            self.conn, self.table_name, url, session, merge=merge
+        )
         self.row_class = self._build_dataclass_from_table()
 
+        if merge:
+            return
+
         if not had_existing:
             return
 
         self.print_diff(old_table)
 
-    def import_csv(self, csv_path: Path):
+    def import_csv(self, csv_path: Path, merge: bool = False):
         """
         Import the passed CSV into the encrypted sqlite database
 
         :param csv_path: Path like path of csv file
+        :param merge: (optional) If True, merge into existing table. Defaults to False.
+            Form importing current, and expired members as headings are the same.
         """
-        had_existing = self.table_exists()
-        old_table = self.rename_old_table(had_existing)
+        had_existing = False
+        old_table = ""
+
+        if not merge:
+            had_existing = self.table_exists()
+            old_table = self.rename_old_table(had_existing)
 
         # Import CSV as new table
-        mojo_loader.import_csv_helper(self.conn, self.table_name, csv_path)
+        mojo_loader.import_csv_helper(self.conn, self.table_name, csv_path, merge=merge)
         self.row_class = self._build_dataclass_from_table()
 
+        if merge:
+            return
+
         if not had_existing:
             return
 
@@ -257,7 +276,7 @@ class MojoSkel:
         self, entry_name: str, entry_value: str, only_one: bool = True
     ) -> Union[sqlite3.Row, List[sqlite3.Row], None]:
         """
-        Retrieve a single row matching column = value (case-insensitive)
+        Retrieve a single or multiple rows matching column = value (case-insensitive)
 
         :param entry_name: Column name to filter by
         :param entry_value: Value to match
@@ -335,12 +354,19 @@ class MojoSkel:
         self.cursor.execute(base_query, values)
         return [self._row_to_obj(row) for row in self.cursor.fetchall()]
 
+    def run_count_query(self, sql: str, params: tuple):
+        """
+        Generate whole sql query for running on db table for counting and run
+
+        :param sql: the sqlite query for matching rows
+        :param params: the paramaters to use for the query
+        """
+        sql_query = f"SELECT count (*) FROM {self.table_name} {sql}"
+        cursor = self.cursor.execute(sql_query, params)
+        return cursor.fetchone()[0]
+
     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;",
-            (self.table_name,),
-        )
-        return self.cursor.fetchone() is not None
+        return mojo_loader.table_exists(self.cursor, self.table_name)

{memberjojo-2.3 → memberjojo-3.0}/src/memberjojo/mojo_loader.py

@@ -125,28 +125,45 @@ def _create_table_from_columns(table_name: str, columns: dict[str, str]) -> str:
     )
 
 
+def table_exists(cursor, table_name: str) -> bool:
+    """
+    Return True or False if a table exists
+
+    :param cursor: SQLite cursor of db to find table in
+    :param table_name: name of the table to check existance of
+
+    :return: bool of existence
+    """
+    cursor.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1;",
+        (table_name,),
+    )
+    return cursor.fetchone() is not None
+
+
 # -----------------------
 # CSV Import
 # -----------------------
 
 
-def import_data(conn, table_name: str, reader: DictReader):
+def import_data(conn, table_name: str, reader: DictReader, merge: bool = False):
     """
     Import data in the DictReader into the SQLite3 database at conn
 
     :param conn: SQLite database connection to use
     :param table_name: Name of the table to import into
     :param reader: A Dictreader object to import from
+    :param merge: (optional) If True, merge into existing table. Defaults to False.
     """
-    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)
+    if not merge or not table_exists(cursor, table_name):
+        # Drop existing table
+        cursor.execute(f'DROP TABLE IF EXISTS "{table_name}";')
+        inferred_cols = infer_columns_from_rows(reader)
+        # Create table
+        create_sql = _create_table_from_columns(table_name, inferred_cols)
+        cursor.execute(create_sql)
 
     # Insert rows
     cols = list(reader[0].keys())
@@ -163,7 +180,7 @@ def import_data(conn, table_name: str, reader: DictReader):
     conn.commit()
 
 
-def import_csv_helper(conn, table_name: str, csv_path: Path):
+def import_csv_helper(conn, table_name: str, csv_path: Path, merge: bool = False):
     """
     Import CSV into database using given cursor
     Column types inferred automatically
@@ -171,6 +188,7 @@ def import_csv_helper(conn, table_name: str, csv_path: Path):
     :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
+    :param merge: (optional) If True, merge into existing table. Defaults to False.
     """
     if not csv_path.exists():
         raise FileNotFoundError(f"CSV file not found: {csv_path}")
@@ -180,7 +198,7 @@ def import_csv_helper(conn, table_name: str, csv_path: Path):
         reader = list(DictReader(f))
         if not reader:
             raise ValueError("CSV file is empty.")
-        import_data(conn, table_name, reader)
+        import_data(conn, table_name, reader, merge=merge)
 
 
 # -----------------------
@@ -350,7 +368,7 @@ def _generate_sql_diff(
 
 
 def download_csv_helper(
-    conn, table_name: str, url: str, session: requests.Session
+    conn, table_name: str, url: str, session: requests.Session, merge: bool = False
 ) -> IO[str]:
     """
     Download url into a StringIO file object using streaming
@@ -360,9 +378,10 @@ def download_csv_helper(
     :param table_name: The name of the table to import it into
     :param url: URL of the csv to download
     :param session: A requests session to use for the download
+    :param merge: (optional) If True, merge into existing table. Defaults to False.
     """
 
-    print(f"Downloading from: {url}")
+    print(f"☁️ Downloading from: {url}")
 
     # Enable streaming
     with session.get(url, stream=True) as resp:
@@ -381,4 +400,4 @@ def download_csv_helper(
         string_buffer.seek(0)
 
         print(f"✅ Downloaded with encoding {resp.encoding}.")
-        import_data(conn, table_name, list(DictReader(string_buffer)))
+        import_data(conn, table_name, list(DictReader(string_buffer)), merge=merge)

{memberjojo-2.3 → memberjojo-3.0}/src/memberjojo/mojo_member.py

@@ -63,6 +63,19 @@ class Member(MojoSkel):
         value = row[0]
         return str(value).lower() == "yes"
 
+    def member_type_count(self, membership_type: str):
+        """
+        Count members by membership type string
+
+        :param membership_type: the string to match, can use percent to match
+            remaining or preceeding text
+                - Full (match only Full)
+                - Full% (match Full and any words after)
+                - %Full% ( match Full in the middle)
+        """
+        query = "WHERE membership LIKE ?"
+        return self.run_count_query(query, (f"{membership_type}",))
+
     def get_number_first_last(
         self, first_name: str, last_name: str, found_error: bool = False
     ) -> Optional[int]:

memberjojo-3.0/tests/test_merge_import.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Merge import tests for MojoSkel
+"""
+
+from memberjojo.mojo_common import MojoSkel
+
+from .utils import write_csv
+
+
+def test_import_merge_csv(tmp_path):
+    """
+    Test importing one CSV, then merging a second CSV,
+    and verify that it appends instead of replacing.
+    """
+
+    # 1. Original CSV
+    csv1 = tmp_path / "members1.csv"
+    original_rows = [
+        {"id": "1", "name": "Alice", "age": "30"},
+    ]
+    write_csv(csv1, original_rows)
+
+    # Create DB
+    db_path = tmp_path / "test_merge.db"
+    password = "Needs a Password"
+
+    # Load initial CSV
+    m = MojoSkel(str(db_path), password, "members")
+    m.import_csv(csv1)
+
+    assert m.count() == 1
+
+    # 2. Second CSV to merge
+    csv2 = tmp_path / "members2.csv"
+    new_rows = [
+        {"id": "2", "name": "Bob", "age": "40"},
+    ]
+    write_csv(csv2, new_rows)
+
+    # Import with merge=True
+    m.import_csv(csv2, merge=True)
+
+    # Should have 2 rows now
+    assert m.count() == 2
+
+    # Verify content
+    # We iterate over m which yields row objects
+    rows = list(m)
+    assert len(rows) == 2
+    names = {r.name for r in rows}
+    assert "Alice" in names
+    assert "Bob" in names
+
+
+def test_import_merge_csv_no_existing(tmp_path):
+    """
+    Test merging into a non-existent table (should act like create).
+    """
+    csv1 = tmp_path / "members_new.csv"
+    rows = [{"id": "1", "name": "Alice", "age": "30"}]
+    write_csv(csv1, rows)
+
+    db_path = tmp_path / "test_merge_new.db"
+    password = "Needs a Password"
+
+    m = MojoSkel(str(db_path), password, "members")
+    # Table doesn't exist yet
+    assert not m.table_exists()
+
+    m.import_csv(csv1, merge=True)
+
+    assert m.table_exists()
+    assert m.count() == 1
+    row = list(m)[0]
+    assert row.name == "Alice"

{memberjojo-2.3 → memberjojo-3.0}/tests/test_mojo_import_diff.py

@@ -3,18 +3,9 @@
 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)
+from .utils import write_csv
 
 
 def test_import_new_csv_generates_diff(tmp_path, capsys):

{memberjojo-2.3 → memberjojo-3.0}/tests/test_mojo_members.py

@@ -25,6 +25,7 @@ def mock_csv_file(tmp_path):
         "Title",
         "First name",
         "Last name",
+        "Membership",
         "membermojo ID",
         "Short URL",
         "Active Member",
@@ -36,6 +37,7 @@ def mock_csv_file(tmp_path):
             "Title": "Mr",
             "First name": "John",
             "Last name": "Doe",
+            "Membership": "Full",
             "membermojo ID": "1001",
             "Short URL": "http://short.url/johndoe",
             "Active Member": "yes",
@@ -46,6 +48,7 @@ def mock_csv_file(tmp_path):
             "Title": "Ms",
             "First name": "Jane",
             "Last name": "Smith",
+            "Membership": "Full",
             "membermojo ID": "1002",
             "Short URL": "http://short.url/janesmith",
             "Active Member": "no",
@@ -56,6 +59,7 @@ def mock_csv_file(tmp_path):
             "Title": "Dr",
             "First name": "Emily",
             "Last name": "Stone",
+            "Membership": "Full",
             "membermojo ID": "1001",
             "Short URL": "http://short.url/emilystone",
             "Active Member": "yes",
@@ -66,6 +70,7 @@ def mock_csv_file(tmp_path):
             "Title": "Mrs",
             "First name": "Sara",
             "Last name": "Connor",
+            "Membership": "Half",
             "membermojo ID": "1003",
             "Short URL": "http://short.url/saraconnor",
             "Active Member": "no",
@@ -76,6 +81,7 @@ def mock_csv_file(tmp_path):
             "Title": "Sir",
             "First name": "Rick",
             "Last name": "Grimes",
+            "Membership": "Half",
             "membermojo ID": "1004",
             "Short URL": "http://short.url/rickgrimes",
             "Active Member": "yes",
@@ -267,3 +273,11 @@ def test_get_fuzz_name_raises_value_error_when_no_match_and_found_error_true(mem
         match=r"❌ Cannot find xyz123notfound in member database with fuzzy match\.",
     ):
         member_db.get_fuzz_name("xyz123notfound", found_error=True)
+
+
+def test_member_count(member_db):
+    """
+    Test member_type_count returns the correct value
+    """
+    assert member_db.member_type_count("half") == 2
+    assert member_db.member_type_count("noop") == 0

memberjojo-3.0/tests/utils.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Utils for tests"""
+
+import csv
+from pathlib import Path
+
+
+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)