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

memberjojo/__init__.py

@@ -10,3 +10,5 @@ except ModuleNotFoundError:
 
 from .mojo_member import Member
 from .mojo_transaction import Transaction
+from .download import Download
+from .url import URL

memberjojo/_version.py

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

memberjojo/download.py

@@ -0,0 +1,116 @@
+"""
+A class for downloading from membermojo
+"""
+
+import getpass
+import re
+from http.cookiejar import MozillaCookieJar
+from pathlib import Path
+import requests
+
+from .url import URL
+
+
+class Download:
+    """A class for managing Membermojo downloads"""
+
+    def __init__(self, shortname: str, cookie_jar: MozillaCookieJar):
+        """
+        Initialise the class
+
+        :param shortname: the membermojo shortname
+        :param cookie_jar: a MozillaCookieJar with the session cookie, or empty to get one
+        """
+        self.url = URL(shortname)
+        self.cookie_jar = cookie_jar
+        self.session = requests.Session()
+        self.session.cookies = self.cookie_jar
+
+    def fill_login(self):
+        """
+        Prompt for email and password to get login data
+
+        :return: a dict of the login data
+        """
+        email = input("📧 Enter your Membermojo email: ").strip()
+        password = getpass.getpass("🔐 Enter your password: ").strip()
+
+        # Submit login form (this triggers verification email if needed)
+        return {"email": email, "password": password}
+
+    def mojo_login(self, login_data: dict, email_verify: bool = False):
+        """
+        Login to membermojo, cookie jar should be saved afterwards with updated cookie
+
+        :param login_data: a dict containing email and password for requests
+        :param email_verify: if True membermojo email verification will be triggered
+            if login fails, or no cookie found to create a new session cookie
+
+        :raises ValueError: If authentication fails and email_verify is False
+        """
+        if not self.session.cookies:
+            if email_verify:
+                print("🍪 No cookies saved, triggering email verification.")
+                self.trigger_email(login_data)
+            else:
+                raise ValueError("⚠️ No cookies found — email verification required.")
+        self.session.post(self.url.login, data=login_data)
+
+        # Attempt to access a protected page to verify login worked
+        print(f"Verifying login with: {self.url.test}")
+        verify_response = self.session.get(self.url.test)
+        if "<mm2-loginpage" in verify_response.text:
+            if email_verify:
+                print("📧 Authentication failed, triggering email verification")
+                self.trigger_email(login_data)
+            else:
+                raise ValueError(
+                    "⚠️ Authentication Failed — email verification required."
+                )
+
+    def trigger_email(self, login_data: dict):
+        """
+        Triggers a login verification email, prompts the user for the verification URL,
+        and then submits it to complete the login process.
+
+        :param login_data: A dictionary containing login credentials (e.g., email)
+
+        :raises: ValueError: If a CSRF token cannot be found or if the login form submission fails
+        """
+        self.session.cookies.clear()
+        response = self.session.post(self.url.login, data=login_data)
+
+        if "check your email" in response.text.lower() or response.ok:
+            print("✅ Login submitted — check your inbox for a verification link.")
+
+            # Get CSRF token from homepage
+            homepage = self.session.get(self.url.base_url)
+            match = re.search(r'"csrf_token":"([^"]+)"', homepage.text)
+            if not match:
+                raise ValueError("❌ Could not find CSRF token.")
+
+            csrf_token = match.group(1)
+            print(f"✅ CSRF token: {csrf_token}")
+
+            # Ask user for the verification link
+            verification_url = input(
+                "🔗 Paste the verification URL from the email: "
+            ).strip()
+
+            # Submit the verification request
+            verify_response = self.session.post(
+                verification_url, data={"csrf_token": csrf_token}
+            )
+
+            # Output
+            if verify_response.ok:
+                print("✅ Verification successful. You're now logged in.")
+            else:
+                print("⚠️ Verification may have failed.")
+                verify_html = Path("verify.html")
+                with verify_html.open("w", encoding="UTF-8") as f:
+                    f.write(verify_response.text)
+
+        else:
+            print(response.text)
+            raise ValueError("❌ Failed to submit login form.")

memberjojo/mojo_common.py

@@ -1,53 +1,69 @@
 """
 MojoSkel base class
 
-This module provides a common base class (`MojoSkel`) for other `memberjojo` modules.
-It includes helper methods for working with SQLite databases.
+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 pprint import pprint
+from typing import Any, Iterator, List, Type, Union
+
+import requests
+
+try:
+    from sqlcipher3 import dbapi2 as sqlite3
+
+    HAS_SQLCIPHER = True
+except ImportError:
+    import sqlite3  # stdlib
 
-from sqlcipher3 import dbapi2 as sqlite3
+    HAS_SQLCIPHER = False
 
 from . import mojo_loader
+from .sql_query import Like
 
 
 class MojoSkel:
     """
     Establishes a connection to a SQLite database and provides helper methods
-    for querying tables.
+    for querying tables
     """
 
     def __init__(self, db_path: str, db_key: str, table_name: str):
         """
-        Initialize the MojoSkel class.
+        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.
+        :param db_path: Path to the SQLite database file
+        :param db_key: key to unlock the encrypted sqlite database,
+            unencrypted if sqlcipher3 not installed or unset
+        :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
+        self.debug = False
 
         # Open connection
-        self.conn = sqlite3.connect(self.db_path)
-        self.conn.row_factory = sqlite3.Row
+        self.conn = sqlite3.connect(self.db_path)  # pylint: disable=no-member
+        self.conn.row_factory = sqlite3.Row  # pylint: disable=no-member
         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.")
+        if HAS_SQLCIPHER and db_key:
+            # 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.")
+        else:
+            print(f"Unencrypted database {self.db_path} loaded securely.")
 
         # After table exists (or after import), build the dataclass
         if self.table_exists():
@@ -55,18 +71,42 @@ class MojoSkel:
         else:
             self.row_class = None
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         """
-        Allow iterating over the class, by outputing all members.
+        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):
+    def _row_to_obj(self, row: sqlite3.Row) -> Type[Any]:
         """
-        Iterate over table rows and yield dynamically-created dataclass objects.
-        Converts REAL columns to Decimal automatically.
+        Convert an sqlite3 row into a dataclass object
+
+        :param row: The sqlite3 row to convert
+
+        :return: A dataclass object of the row
+        """
+        row_dict = dict(row)
+
+        # Convert REAL → Decimal (including numeric strings)
+        for k, v in row_dict.items():
+            if isinstance(v, float):
+                row_dict[k] = Decimal(str(v))
+            elif isinstance(v, str):
+                try:
+                    row_dict[k] = Decimal(v)
+                except InvalidOperation:
+                    pass
+
+        return self.row_class(**row_dict)
+
+    def _iter_rows(self) -> Iterator[Any]:
+        """
+        Iterate over table rows and yield dynamically-created dataclass objects
+        Converts REAL columns to Decimal automatically
+
+        :return: An interator of dataclass objects for rows
         """
 
         sql = f'SELECT * FROM "{self.table_name}"'
@@ -75,29 +115,18 @@ class MojoSkel:
         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):
+            yield self._row_to_obj(row)
+
+    def _build_dataclass_from_table(self) -> Type[Any]:
         """
-        Dynamically create a dataclass from the table schema.
+        Dynamically create a dataclass from the table schema
         INTEGER → int
         REAL → Decimal
         TEXT → str
 
-        :return: A dataclass built from the table columns and types.
+        :return: A dataclass built from the table columns and types
+
+        :raises ValueError: If no table
         """
         self.cursor.execute(f'PRAGMA table_info("{self.table_name}")')
         cols = self.cursor.fetchall()
@@ -120,30 +149,29 @@ class MojoSkel:
 
         return make_dataclass(f"{self.table_name}_Row", fields)
 
-    def import_csv(self, csv_path: Path):
+    def rename_old_table(self, existing: bool) -> str:
         """
-        Import the passed CSV into the encrypted sqlite database.
-        If a previous table exists, generate a diff using
-        mojo_loader.diff_cipher_tables().
+        If there was an exising table rename for comparison
 
-        :param csv_path: Path like path of csv file.
+        :param existing: bool for table exists
+
+        :return: the old table name
         """
         old_table = f"{self.table_name}_old"
-        had_existing = self.table_exists()
-
-        # 1. Preserve existing table
-        if had_existing:
+        self.conn.execute(f"DROP TABLE IF EXISTS {old_table}")
+        # Preserve existing table
+        if existing:
             self.conn.execute(f"ALTER TABLE {self.table_name} RENAME TO {old_table}")
+        return 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
+    def print_diff(self, old_table: str):
+        """
+        Print out diff between old and new db
 
+        :param old_table: The name the existing table was renamed to
+        """
         try:
-            # 3. Diff old vs new (SQLCipher → sqlite3 → dataclasses)
+            # Diff old vs new (SQLCipher → sqlite3 → dataclasses)
             diff_rows = mojo_loader.diff_cipher_tables(
                 self.conn,
                 new_table=self.table_name,
@@ -156,14 +184,52 @@ class MojoSkel:
                     print(diff.diff_type, diff.preview)
 
         finally:
-            # 4. Cleanup old table (always)
+            # Cleanup old table (always)
             self.conn.execute(f"DROP TABLE {old_table}")
 
+    def download_csv(self, session: requests.Session, url: str):
+        """
+        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
+        """
+        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)
+        self.row_class = self._build_dataclass_from_table()
+
+        if not had_existing:
+            return
+
+        self.print_diff(old_table)
+
+    def import_csv(self, csv_path: Path):
+        """
+        Import the passed CSV into the encrypted sqlite database
+
+        :param csv_path: Path like path of csv file
+        """
+        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)
+        self.row_class = self._build_dataclass_from_table()
+
+        if not had_existing:
+            return
+
+        self.print_diff(old_table)
+
     def show_table(self, limit: int = 2):
         """
-        Print the first few rows of the table as dictionaries.
+        Print the first few rows of the table as dictionaries
 
-        :param limit: (optional) Number of rows to display. Defaults to 2.
+        :param limit: (optional) Number of rows to display. Defaults to 2
         """
         if self.table_exists():
             self.cursor.execute(f'SELECT * FROM "{self.table_name}" LIMIT ?', (limit,))
@@ -178,7 +244,7 @@ class MojoSkel:
 
     def count(self) -> int:
         """
-        :return: count of the number of rows in the table, or 0 if no table.
+        :return: count of the number of rows in the table, or 0 if no table
         """
         if self.table_exists():
             self.cursor.execute(f'SELECT COUNT(*) FROM "{self.table_name}"')
@@ -187,33 +253,34 @@ class MojoSkel:
 
         return 0
 
-    def get_row(self, entry_name: str, entry_value: str) -> dict:
+    def get_row(
+        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 row matching column = value (case-insensitive)
 
-        :param entry_name: Column name to filter by.
-        :param entry_value: Value to match.
+        :param entry_name: Column name to filter by
+        :param entry_value: Value to match
+        :param only_one: If True (default), return the first matching row
+                If False, return a list of all matching rows
 
-        :return: The matching row as a dictionary, or None if not found.
+        :return:
+            - If only_one=True → a single sqlite3.Row or None
+            - If only_one=False → list of sqlite3.Row (may be empty)
         """
-        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
+        match_dict = {f"{entry_name}": entry_value}
+
+        return self.get_row_multi(match_dict, only_one)
 
     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.
+        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.
+        :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
@@ -225,6 +292,23 @@ class MojoSkel:
         for col, val in match_dict.items():
             if val is None or val == "":
                 conditions.append(f'"{col}" IS NULL')
+            elif isinstance(val, Like):
+                conditions.append(f'LOWER("{col}") LIKE LOWER(?)')
+                values.append(val.pattern)
+            elif isinstance(val, (tuple, list)) and len(val) == 2:
+                lower, upper = val
+                if lower is not None and upper is not None:
+                    conditions.append(f'"{col}" BETWEEN ? AND ?')
+                    values.extend([lower, upper])
+                elif lower is not None:
+                    conditions.append(f'"{col}" >= ?')
+                    values.append(lower)
+                elif upper is not None:
+                    conditions.append(f'"{col}" <= ?')
+                    values.append(upper)
+                else:
+                    # Both are None, effectively no condition on this column
+                    pass
             else:
                 conditions.append(f'"{col}" = ?')
                 values.append(
@@ -233,22 +317,27 @@ class MojoSkel:
                     else val
                 )
 
+        # Base query string
         base_query = (
             f'SELECT * FROM "{self.table_name}" WHERE {" AND ".join(conditions)}'
         )
+        if self.debug:
+            print("Sql:")
+            pprint(base_query)
 
         if only_one:
             query = base_query + " LIMIT 1"
             self.cursor.execute(query, values)
-            return self.cursor.fetchone()
+            if row := self.cursor.fetchone():
+                return self._row_to_obj(row)
+            return None
 
-        # Return *all* rows
         self.cursor.execute(base_query, values)
-        return self.cursor.fetchall()
+        return [self._row_to_obj(row) for row in self.cursor.fetchall()]
 
     def table_exists(self) -> bool:
         """
-        Return true or false if a table exists
+        Return True or False if a table exists
         """
         self.cursor.execute(
             "SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1;",

memberjojo/mojo_loader.py

@@ -1,22 +1,25 @@
 #!/usr/bin/env python3
 """
-Helper module for importing a CSV into a SQLite database.
+Helper module for importing a CSV into a SQLite database
 """
 
 from collections import defaultdict, Counter
 from csv import DictReader
 from dataclasses import dataclass
+from io import StringIO
 from pathlib import Path
-from typing import Any, Tuple
+from typing import Any, IO, Tuple
 
 import re
 import sqlite3 as sqlite3_builtin
 
+import requests
+
 
 @dataclass(frozen=True)
 class DiffRow:
     """
-    Represents a single diff result.
+    Represents a single diff result
 
     - diff_type: 'added' | 'deleted' | 'changed'
     - preview: tuple of values, with preview[0] == key
@@ -33,11 +36,11 @@ class DiffRow:
 
 def _normalize(name: str) -> str:
     """
-    Normalize a column name: lowercase, remove symbols, convert to snake case.
+    Normalize a column name: lowercase, remove symbols, convert to snake case
 
-    :param name: Raw name to normalize.
+    :param name: Raw name to normalize
 
-    :return: Normalized lowercase string in snake case with no symbols.
+    :return: Normalized lowercase string in snake case with no symbols
     """
     name = name.strip().lower()
     name = re.sub(r"[^a-z0-9]+", "_", name)
@@ -46,7 +49,7 @@ def _normalize(name: str) -> str:
 
 def _guess_type(value: any) -> str:
     """
-    Guess SQLite data type of a CSV value: 'INTEGER', 'REAL', or 'TEXT'.
+    Guess SQLite data type of a CSV value: 'INTEGER', 'REAL', or 'TEXT'
 
     :param value: entry from sqlite database to guess the type of
 
@@ -71,8 +74,8 @@ def _guess_type(value: any) -> str:
 
 def infer_columns_from_rows(rows: list[dict]) -> dict[str, str]:
     """
-    Infer column types from CSV rows.
-    Returns mapping: normalized column name -> SQLite type.
+    Infer column types from CSV rows
+    Returns mapping: normalized column name -> SQLite type
 
     :param rows: list of rows to use for inference
 
@@ -104,22 +107,18 @@ def infer_columns_from_rows(rows: list[dict]) -> dict[str, str]:
 
 def _create_table_from_columns(table_name: str, columns: dict[str, str]) -> str:
     """
-    Generate CREATE TABLE SQL from column type mapping.
+    Generate CREATE TABLE SQL from column type mapping
+    Adds an auto-incrementing rowid as the primary key
 
-    :param table_name: Table to use when creating columns.
-    :param columns: dict of columns to create.
+    :param table_name: Table to use when creating columns
+    :param columns: dict of columns to create
 
-    :return: SQL commands to create the table.
+    :return: SQL commands to create the table
     """
-    col_defs = []
-    first = True
+    col_defs = ["rowid INTEGER PRIMARY KEY AUTOINCREMENT"]
 
     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}')
+        col_defs.append(f'"{col}" {col_type}')
 
     return (
         f'CREATE TABLE IF NOT EXISTS "{table_name}" (\n' + ",\n".join(col_defs) + "\n)"
@@ -131,14 +130,47 @@ def _create_table_from_columns(table_name: str, columns: dict[str, str]) -> str:
 # -----------------------
 
 
+def import_data(conn, table_name: str, reader: DictReader):
+    """
+    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
+    """
+    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()
+
+
 def import_csv_helper(conn, table_name: str, csv_path: Path):
     """
-    Import CSV into database using given cursor.
-    Column types inferred automatically.
+    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.
+    :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}")
@@ -148,29 +180,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.")
-        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()
+        import_data(conn, table_name, reader)
 
 
 # -----------------------
@@ -180,7 +190,7 @@ def import_csv_helper(conn, table_name: str, csv_path: Path):
 
 def _diffrow_from_sql_row(row: sqlite3_builtin.Row) -> DiffRow:
     """
-    Convert a sqlite3.Row from generate_sql_diff into DiffRow.
+    Convert a sqlite3.Row from generate_sql_diff into DiffRow
     Row shape:
         (diff_type, col1, col2, col3, ...)
 
@@ -195,7 +205,7 @@ def _diffrow_from_sql_row(row: sqlite3_builtin.Row) -> DiffRow:
 
 
 def diff_cipher_tables(
-    cipher_conn,
+    conn,
     *,
     new_table: str,
     old_table: str,
@@ -204,7 +214,7 @@ def diff_cipher_tables(
     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 conn: sqlite connection to the db
     :param new_table: name of the new table for comparison
     :param old_table: name of the old table for comparison
 
@@ -216,8 +226,8 @@ def diff_cipher_tables(
 
     try:
         for table in (old_table, new_table):
-            # 1. Clone schema using SQLite itself
-            schema_sql = cipher_conn.execute(
+            # Clone schema using SQLite itself
+            schema_sql = conn.execute(
                 """
                 SELECT sql
                 FROM sqlite_master
@@ -232,7 +242,7 @@ def diff_cipher_tables(
             plain.execute(schema_sql[0])
 
             # 2. Copy data
-            rows = cipher_conn.execute(f"SELECT * FROM {table}")
+            rows = conn.execute(f"SELECT * FROM {table}")
             cols = [d[0] for d in rows.description]
 
             col_list = ", ".join(cols)
@@ -263,9 +273,9 @@ def _generate_sql_diff(
     old_table: str,
 ) -> list[sqlite3_builtin.Row]:
     """
-    Generate a diff between two tables using standard SQLite features.
+    Generate a diff between two tables using standard SQLite features
 
-    - The FIRST column is the primary key.
+    - Uses rowid as the primary key for joining
     - Returned row shape:
             (diff_type, preview_col1, preview_col2, preview_col3, ...)
 
@@ -276,7 +286,7 @@ def _generate_sql_diff(
     :return: list of sqlite rows that are changed
     """
 
-    # 1. Introspect schema (order-preserving)
+    # Introspect schema (order-preserving)
     cols_info = conn.execute(f"PRAGMA table_info({new_table})").fetchall()
 
     if not cols_info:
@@ -284,16 +294,20 @@ def _generate_sql_diff(
 
     cols = [row[1] for row in cols_info]
 
-    key = cols[0]
-    non_key_cols = cols[1:]
+    # Exclude rowid from consideration for key or data
+    main_cols = [c for c in cols if c != "rowid"]
 
-    # 2. Preview columns (key first, limit for readability)
+    # First column is key, others are for comparison
+    key = main_cols[0]
+    non_key_cols = main_cols[1:]
+
+    #  Preview columns (key first, then others 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)
+    # Row-value comparison (NULL-safe)
     if non_key_cols:
         changed_predicate = (
             f"({', '.join(f'n.{c}' for c in non_key_cols)}) "
@@ -333,3 +347,38 @@ def _generate_sql_diff(
         """
 
     return list(conn.execute(sql))
+
+
+def download_csv_helper(
+    conn, table_name: str, url: str, session: requests.Session
+) -> IO[str]:
+    """
+    Download url into a StringIO file object using streaming
+    and import into database
+
+    :param conn: The SQLite3 database connection to use
+    :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
+    """
+
+    print(f"Downloading from: {url}")
+
+    # Enable streaming
+    with session.get(url, stream=True) as resp:
+        resp.raise_for_status()
+
+        # Initialize the string buffer
+        string_buffer = StringIO()
+
+        # Stream decoded text
+        # decode_unicode=True uses the encoding from the response headers
+        for chunk in resp.iter_content(chunk_size=8192, decode_unicode=True):
+            if chunk:
+                string_buffer.write(chunk)
+
+        # Reset pointer to the beginning for DictReader
+        string_buffer.seek(0)
+
+        print(f"✅ Downloaded with encoding {resp.encoding}.")
+        import_data(conn, table_name, list(DictReader(string_buffer)))

memberjojo/mojo_member.py

@@ -1,25 +1,28 @@
 """
-Member module for creating and interacting with a SQLite database.
+Member module for creating and interacting with a SQLite database
 
 This module loads data from a `members.csv` file downloaded from Membermojo,
-stores it in SQLite, and provides helper functions for member lookups.
+stores it in SQLite, and provides helper functions for member lookups
 """
 
+from difflib import get_close_matches
 from pathlib import Path
+from pprint import pprint
 from typing import Optional
 from .mojo_common import MojoSkel
 
 
 class Member(MojoSkel):
     """
-    Subclass of MojoSkel providing member-specific database functions.
+    Subclass of MojoSkel providing member-specific database functions
 
     This class connects to a SQLite database and supports importing member data
-    from CSV and performing queries like lookup by name or member number.
+    from CSV and performing queries like lookup by name or member number
 
-    :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.
+    :param member_db_path (Path): Path to the SQLite database file
+    :param db_key: key to unlock the encrypted sqlite database,
+        unencrypted if sqlcipher3 not installed or unset
+    :param table_name (str): (optional) Table name to use. Defaults to "members"
     """
 
     def __init__(
@@ -29,23 +32,50 @@ class Member(MojoSkel):
         table_name: str = "members",
     ):
         """
-        Initialize the Member database handler.
+        Initialize the Member database handler
         """
         super().__init__(member_db_path, db_key, table_name)
 
+    def get_bool(self, entry_name: str, member_number: int) -> bool:
+        """
+        Return a bool for a member entry that is a tick box on membermojo
+
+        :param entry_name: The entry name to return as a bool
+        :param member_number: The member number to check value of entry_name
+
+        :return: True is entry is yes otherwise False
+
+        :raises ValueError: If entry name not found
+        """
+        sql = f"""
+            SELECT "{entry_name}"
+            FROM "{self.table_name}"
+            WHERE "member_number" = ?
+        """
+        self.cursor.execute(sql, (member_number,))
+
+        row = self.cursor.fetchone()
+        if row is None:
+            raise ValueError(
+                f"❌ Cannot find: {entry_name} for member {member_number}."
+            )
+
+        value = row[0]
+        return str(value).lower() == "yes"
+
     def get_number_first_last(
         self, first_name: str, last_name: str, found_error: bool = False
     ) -> Optional[int]:
         """
-        Find a member number based on first and last name (case-insensitive).
+        Find a member number based on first and last name (case-insensitive)
 
-        :param first_name: First name of the member.
-        :param last_name: Last name of the member.
-        :param found_error: (optional): If True, raises ValueError if not found.
+        :param first_name: First name of the member
+        :param last_name: Last name of the member
+        :param found_error: (optional): If True, raises ValueError if not found
 
-        :return: The member number if found, otherwise None.
+        :return: The member number if found, otherwise None
 
-        :raises ValueError: If not found and `found_error` is True.
+        :raises ValueError: If not found and `found_error` is True
         """
         sql = f"""
             SELECT "member_number"
@@ -54,6 +84,12 @@ class Member(MojoSkel):
         """
         self.cursor.execute(sql, (first_name, last_name))
         result = self.cursor.fetchone()
+        if self.debug:
+            print("Sql:")
+            pprint(sql)
+            print(f"First Name: {first_name} Last Name: {last_name}")
+            print("Result:")
+            pprint(result[0])
 
         if not result and found_error:
             raise ValueError(
@@ -64,18 +100,22 @@ class Member(MojoSkel):
 
     def get_number(self, full_name: str, found_error: bool = False) -> Optional[int]:
         """
-        Find a member number by passed full_name.
+        Find a member number by passed full_name
         Tries first and last, and then middle last if 3 words,
-        Then initial of first name if initials passed.
+        Then initial of first name if initials passed
+        Finnaly a fuzzy lookup is tried
 
-        :param full_name: Full name of the member.
-        :param found_error: (optional) Raise ValueError if not found.
+        :param full_name: Full name of the member
+        :param found_error: (optional) Raise ValueError if not found
 
-        :return: Member number if found, else None.
+        :return: Member number if found, else None
 
-        :raises ValueError: If not found and `found_error` is True.
+        :raises ValueError: If not found and `found_error` is True
         """
-        result = self.get_mojo_name(full_name, found_error)
+        result = self.get_mojo_name(full_name)
+        if not result:
+            result = self.get_fuzz_name(full_name, found_error)
+
         if result:
             return self.get_number_first_last(result[0], result[1])
         return None
@@ -123,7 +163,7 @@ class Member(MojoSkel):
         self, full_name: str, found_error: bool = False
     ) -> Optional[tuple]:
         """
-        Resolve a member name from a free-text full name.
+        Resolve a member name from a free-text full name
 
         **Search order**
 
@@ -132,14 +172,14 @@ class Member(MojoSkel):
         3. initial 1st letter + last
         4. initial 2nd letter + last (for two-letter initials)
 
-        Returns (first_name, last_name) or None.
+        Returns (first_name, last_name) or None
 
-        :param full_name: Full name of the member to find.
-        :param found_error: (optional) Raise ValueError if not found.
+        :param full_name: Full name of the member to find
+        :param found_error: (optional) Raise ValueError if not found
 
-        :return: Membermojo name if found, else None.
+        :return: Membermojo name if found, else None
 
-        :raises ValueError: If not found and `found_error` is True.
+        :raises ValueError: If not found and `found_error` is True
         """
 
         parts = full_name.strip().split()
@@ -207,11 +247,11 @@ class Member(MojoSkel):
 
     def get_first_last_name(self, member_number: int) -> Optional[str]:
         """
-        Get full name for a given member number.
+        Get full name for a given member number
 
-        :param member_number: Member number to look up.
+        :param member_number: Member number to look up
 
-        :return: Full name as tuple, or None if not found.
+        :return: Full name as tuple, or None if not found
         """
         sql = f"""
             SELECT "first_name", "last_name"
@@ -225,11 +265,11 @@ class Member(MojoSkel):
 
     def get_name(self, member_number: int) -> Optional[str]:
         """
-        Get full name for a given member number.
+        Get full name for a given member number
 
-        :param member_number: Member number to look up.
+        :param member_number: Member number to look up
 
-        :return: Full name as "First Last", or None if not found.
+        :return: Full name as "First Last", or None if not found
         """
 
         result = self.get_first_last_name(member_number)
@@ -238,3 +278,39 @@ class Member(MojoSkel):
             first_name, last_name = result
             return f"{first_name} {last_name}"
         return None
+
+    def get_fuzz_name(self, name: str, found_error: bool = False):
+        """
+        Fuzzy search for members by name using partial matching
+        Searches across first_name and last_name fields
+
+        :param name: Free text name to search for (partial match)
+
+
+        :return: Tuple of (first_name, last_name) or None
+
+        :raises ValueError: If not found and `found_error` is True
+        """
+
+        name = name.strip().lower()
+
+        # Get all members
+        self.cursor.execute(
+            f'SELECT *, LOWER(first_name || " " || last_name) AS full FROM "{self.table_name}"'
+        )
+        rows = self.cursor.fetchall()
+
+        choices = [row["full"] for row in rows]
+        matches = get_close_matches(name, choices, n=1, cutoff=0.7)
+
+        if not matches:
+            if found_error:
+                raise ValueError(
+                    f"❌ Cannot find {name} in member database with fuzzy match."
+                )
+            return None
+
+        match = matches[0]
+        # return the sqlite row for the best match
+        row = next(r for r in rows if r["full"] == match)
+        return (row["first_name"], row["last_name"])

memberjojo/mojo_transaction.py

@@ -1,8 +1,8 @@
 """
-Module to import and interact with Membermojo completed_payments.csv data in SQLite.
+Module to import and interact with Membermojo completed_payments.csv data in SQLite
 
 Provides automatic column type inference, robust CSV importing, and
-helper methods for querying the database.
+helper methods for querying the database
 """
 
 from .mojo_common import MojoSkel
@@ -10,14 +10,15 @@ from .mojo_common import MojoSkel
 
 class Transaction(MojoSkel):
     """
-    Handles importing and querying completed payment data.
+    Handles importing and querying completed payment data
 
     Extends:
-        MojoSkel: Base class with transaction database operations.
+        MojoSkel: Base class with transaction database operations
 
-    :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.
+    :param payment_db_path: Path to the SQLite database
+    :param db_key: key to unlock the encrypted sqlite database,
+        unencrypted if sqlcipher3 not installed or unset
+    :param table_name: (optional) Name of the table. Defaults to "payments"
     """
 
     def __init__(
@@ -27,6 +28,6 @@ class Transaction(MojoSkel):
         table_name: str = "payments",
     ):
         """
-        Initialize the Transaction object.
+        Initialize the Transaction object
         """
         super().__init__(payment_db_path, db_key, table_name)

memberjojo/sql_query.py

@@ -0,0 +1,12 @@
+"""
+Classes for use in sqlite row matching
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Like:
+    """Marker type for SQL LIKE comparisons"""
+
+    pattern: str

memberjojo/url.py

@@ -0,0 +1,82 @@
+"""
+A class for managing Membermojo URLs
+"""
+
+
+class URL:
+    """A class for managing Membermojo URLs"""
+
+    def __init__(self, shortname: str):
+        """
+        Ininitalise the class
+
+        :param shortname: the shortname setting on membermojo
+        """
+        self.shortname = shortname
+        self.base_url = "https://membermojo.co.uk"
+
+    def make_url(self, endpoint: str) -> str:
+        """
+        return a whole url for endpoint
+
+        :param endpoint: the endpoint to make url for
+
+        :return: a complete url
+        """
+        return f"{self.base_url}/{self.shortname}/{endpoint}"
+
+    def members(self, state: str = "") -> str:
+        """
+        return the active, expired, or archived urls
+
+        :param state: membership state to return
+
+        :return: url for the state
+
+        state:
+            "active" or "" -> active members
+            "expired" -> expired members
+            "archived" -> archived members
+        """
+        if state not in {"", "expired", "archived"}:
+            raise ValueError(f"Invalid member state: {state}")
+
+        if state == "active":
+            state = ""
+        suffix = f"_{state}" if state else ""
+        return f"{self.membership}/download{suffix}_members"
+
+    @property
+    def login(self):
+        """Returns the membermojo login URL"""
+        return self.make_url("signin_password")
+
+    @property
+    def membership(self):
+        """Returns the URL for membership"""
+        return self.make_url("membership")
+
+    @property
+    def completed_payments(self):
+        """Returns the completed payments download URL"""
+        return f"{self.membership}/download_completed_payments?state=CO"
+
+    @property
+    def pending_aproval(self):
+        """Returns the members pending approval URL"""
+        return f"{self.membership}/download_pending_approval_members"
+
+    @property
+    def pending_completion(self):
+        """Returns the members pending completion URL"""
+        return f"{self.membership}/download_pending_completion_members"
+
+    @property
+    def pending_payments(self):
+        """Returns the members pending payments URL"""
+        return f"{self.membership}/download_pending_payments"
+
+    @property
+    def test(self):
+        """Returns the test URL for login verification"""
+        return self.membership

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

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: memberjojo
-Version: 2.2
+Version: 2.3
 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"
@@ -17,28 +16,34 @@ Requires-Dist: sphinx>=7.0 ; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints ; extra == "docs"
 Requires-Dist: black ; extra == "lint"
 Requires-Dist: pylint ; extra == "lint"
+Requires-Dist: sqlcipher3 ; extra == "sqlcipher"
 Project-URL: Home, https://github.com/a16bitsysop/memberjojo
 Provides-Extra: dev
 Provides-Extra: docs
 Provides-Extra: lint
+Provides-Extra: sqlcipher
 
 # memberjojo
 
 `memberjojo` is a Python library for using [Membermojo](http://membermojo.co.uk/)
 data from CSV imports.\
 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.\
+This is done in a local SQLite database which is optionally encrypted if sqlcipher3
+is installed, 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 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 with a summary
+diff printed out.
+
+Using the download_csv function the csv can be downloaded directly into the db,
+which can also be in memory if :memory: is used as the db path.
 
 ---
 
 ## Installation
 
-Installing via `pip` on macos with `sqlcipher` installed via homebrew:\
+Installing via `pip` on macos with optional `sqlcipher` installed via homebrew:\
 (The sqlcipher bindings are compiled by pip so the `C_INCLUDE_PATH` and
 `LIBRARY_PATH` are needed for the `libsqlcipher` files to be found)
 
@@ -46,13 +51,19 @@ Installing via `pip` on macos with `sqlcipher` installed via homebrew:\
 brew install sqlcipher
 export C_INCLUDE_PATH="/opt/homebrew/opt/sqlcipher/include"
 export LIBRARY_PATH="/opt/homebrew/opt/sqlcipher/lib"
-pip install memberjojo
+pip install memberjojo[sqlciper]
 ```
 
 Installing via `pip` on ubuntu:
 
 ```bash
 sudo apt-get --no-install-recommends --no-install-suggests install libsqlcipher-dev
+pip install memberjojo[sqlcipher]
+```
+
+Installing via `pip` without sqlcipher:
+
+```bash
 pip install memberjojo
 ```
 

memberjojo-2.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+memberjojo/__init__.py,sha256=kO0EB2VTfHQFyqERL0qKRlYzAkD_cTm-b3q3uT1r91g,343
+memberjojo/_version.py,sha256=2i05UdhZ8zjlTikPn5gGyFdwY-FJwBWYSRHEBlHO5KU,699
+memberjojo/download.py,sha256=N8s5kFm58gbOaPyWvXxRigbMk5J6vjOx4_GX--JtWFY,4387
+memberjojo/mojo_common.py,sha256=lE9LVVMGI5mbw5n6ZItvqSdswb4sJfLdwfRsgEocGuA,11415
+memberjojo/mojo_loader.py,sha256=QOEPqVrswI82xqkj9CbtGmjRX9sqpRWZBSyhEnm82Os,10758
+memberjojo/mojo_member.py,sha256=mr-4C4W_swzxQ1PcNi0884k59eRGo8fABAEQ0WVjyRo,10472
+memberjojo/mojo_transaction.py,sha256=KCbhrY1Wccs_GoXHtuXgohn5MdxnUiMpKdhcVE348KU,933
+memberjojo/sql_query.py,sha256=4T6EVYZo7q0VQ2Ah6uuX20Ub_g0RsBoKs1qrZmqRK7w,185
+memberjojo/url.py,sha256=vx-l1FlrohlpAExPICU5UYRl34z_tYXvWLzGAaprdXI,2320
+memberjojo-2.3.dist-info/licenses/LICENSE,sha256=eaTLEca5OoRQ9r8GlC6Rwa1BormM3q-ppDWLFFxhQxI,1071
+memberjojo-2.3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+memberjojo-2.3.dist-info/METADATA,sha256=_1PYJvM6M4f82d4WB-f0tOy7TghxL86HbmURa8RWT3U,3964
+memberjojo-2.3.dist-info/RECORD,,

memberjojo-2.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-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,,