Add bulk notes import

README.md

@@ -6,6 +6,7 @@ The current version focuses on a clean, deterministic foundation:
 
 - Record a transaction with your microphone and transcribe it with faster-whisper.
 - Type or paste a transaction note.
+- Bulk import multiple pasted notes for review and editing.
 - Parse it with simple rules.
 - Save the structured transaction to SQLite.
 - View the ledger, customer credit book, and inventory in a Gradio interface.
@@ -20,7 +21,9 @@ LLM parsing is intentionally not implemented yet.
 | Input | Parsed result |
 | --- | --- |
 | `Sold 12 mangoes, 20 each` | Sale, quantity `12`, item `mangoes`, unit price `20`, amount `240` |
+| `mango 12 x 20` | Sale, quantity `12`, item `mango`, unit price `20`, amount `240` |
 | `Paid 500 for supplies` | Expense, amount `500`, item `supplies` |
+| `rent 300` | Expense, amount `300`, item `rent` |
 | `Bought 50 mangoes` | Inventory purchase, quantity `50`, item `mangoes` |
 | `Amit owes 100` | Customer credit, customer `Amit`, amount `100` |
 | `Amit paid 50` | Customer payment, customer `Amit`, amount `50` |
@@ -74,3 +77,4 @@ pytest
 - Parser architecture supports rule-based and Hugging Face Inference API compatible LLM parsers, with rule fallback on LLM failure.
 - The dashboard shows daily sales, expenses, profit, outstanding credit, top sellers, and low-stock alerts from saved data.
 - WhatsApp summaries provide a short copyable daily recap for sharing.
+- Bulk import splits pasted notes by line, parses each line, supports review edits, and saves all reviewed transactions.

tests/test_bulk_import.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+from voiceledger.ledger.customers import get_customer_balances
+from voiceledger.ledger.database import add_transaction, get_transactions
+from voiceledger.parser.bulk import parse_bulk_notes, review_table_to_transactions
+
+
+def test_parse_bulk_notes_splits_lines_and_parses_each_transaction() -> None:
+    notes = """
+    mango 12 x 20
+    rent 300
+    Amit owes 100
+    Ramesh paid 50
+    """
+
+    review_table = parse_bulk_notes(notes)
+
+    assert len(review_table) == 4
+    assert review_table.iloc[0]["transaction_type"] == "sale"
+    assert review_table.iloc[0]["item"] == "mango"
+    assert review_table.iloc[0]["quantity"] == 12
+    assert review_table.iloc[0]["unit_price"] == 20
+    assert review_table.iloc[0]["amount"] == 240
+    assert review_table.iloc[1]["transaction_type"] == "expense"
+    assert review_table.iloc[1]["item"] == "rent"
+    assert review_table.iloc[1]["amount"] == 300
+    assert review_table.iloc[2]["transaction_type"] == "customer_credit"
+    assert review_table.iloc[2]["customer"] == "Amit"
+    assert review_table.iloc[3]["transaction_type"] == "customer_payment"
+    assert review_table.iloc[3]["customer"] == "Ramesh"
+
+
+def test_review_table_to_transactions_uses_edited_values() -> None:
+    review_table = parse_bulk_notes("mango 12 x 20")
+    review_table.loc[0, "quantity"] = 10
+    review_table.loc[0, "amount"] = 200
+
+    transactions = review_table_to_transactions(review_table)
+
+    assert len(transactions) == 1
+    assert transactions[0].quantity == 10
+    assert transactions[0].amount == 200
+
+
+def test_bulk_transactions_save_through_ledger_path(tmp_path: Path) -> None:
+    db_path = tmp_path / "voiceledger.sqlite3"
+    review_table = parse_bulk_notes("mango 12 x 20\nAmit owes 100")
+
+    for transaction in review_table_to_transactions(review_table):
+        add_transaction(transaction, db_path)
+
+    ledger = get_transactions(db_path)
+    balances = get_customer_balances(db_path)
+
+    assert len(ledger) == 2
+    assert balances.iloc[0]["customer"] == "Amit"
+    assert balances.iloc[0]["outstanding_balance"] == 100

tests/test_parser.py

@@ -12,6 +12,16 @@ def test_parse_sale_with_quantity_and_unit_price() -> None:
     assert transaction.payment_status == "paid"
 
 
+def test_parse_shorthand_sale() -> None:
+    transaction = parse_transaction("mango 12 x 20")
+
+    assert transaction.transaction_type == "sale"
+    assert transaction.item == "mango"
+    assert transaction.quantity == 12
+    assert transaction.unit_price == 20
+    assert transaction.amount == 240
+
+
 def test_parse_expense() -> None:
     transaction = parse_transaction("Paid 500 for supplies")
 
@@ -21,6 +31,14 @@ def test_parse_expense() -> None:
     assert transaction.payment_status == "paid"
 
 
+def test_parse_shorthand_expense() -> None:
+    transaction = parse_transaction("rent 300")
+
+    assert transaction.transaction_type == "expense"
+    assert transaction.item == "rent"
+    assert transaction.amount == 300
+
+
 def test_parse_inventory_purchase() -> None:
     transaction = parse_transaction("Bought 50 mangoes")
 

voiceledger/parser/__init__.py

@@ -1,9 +1,18 @@
 """Parsing utilities for transaction notes."""
 
 from voiceledger.parser.base import Parser
+from voiceledger.parser.bulk import parse_bulk_notes, review_table_to_transactions
 from voiceledger.parser.llm_parser import LLMParser
 from voiceledger.parser.rules import RuleParser
 from voiceledger.parser.rules import parse_transaction
 from voiceledger.parser.schema import Transaction
 
-__all__ = ["Transaction", "Parser", "RuleParser", "LLMParser", "parse_transaction"]
+__all__ = [
+    "Transaction",
+    "Parser",
+    "RuleParser",
+    "LLMParser",
+    "parse_transaction",
+    "parse_bulk_notes",
+    "review_table_to_transactions",
+]

voiceledger/parser/bulk.py

@@ -0,0 +1,116 @@
+"""Bulk note parsing helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+from voiceledger.parser.rules import parse_transaction
+from voiceledger.parser.schema import Transaction
+
+
+REVIEW_COLUMNS = [
+    "transaction_type",
+    "item",
+    "quantity",
+    "unit_price",
+    "amount",
+    "customer",
+    "payment_status",
+    "notes",
+    "confidence",
+]
+
+
+def parse_bulk_notes(notes: str) -> pd.DataFrame:
+    """Split pasted notes into lines and parse each line for review."""
+    transactions = [parse_transaction(line) for line in _split_note_lines(notes)]
+    return transactions_to_dataframe(transactions)
+
+
+def transactions_to_dataframe(transactions: list[Transaction]) -> pd.DataFrame:
+    """Convert transactions into an editable review DataFrame."""
+    records = [transaction.model_dump() for transaction in transactions]
+    return pd.DataFrame.from_records(records, columns=REVIEW_COLUMNS)
+
+
+def review_table_to_transactions(review_table: Any) -> list[Transaction]:
+    """Convert an edited review table back into validated transactions."""
+    frame = _coerce_review_table(review_table)
+    transactions: list[Transaction] = []
+
+    for record in frame.to_dict(orient="records"):
+        cleaned = _clean_record(record)
+        if _is_empty_record(cleaned):
+            continue
+        transactions.append(Transaction(**cleaned))
+
+    return transactions
+
+
+def _split_note_lines(notes: str) -> list[str]:
+    """Return non-empty stripped lines from pasted notes."""
+    return [line.strip() for line in (notes or "").splitlines() if line.strip()]
+
+
+def _coerce_review_table(review_table: Any) -> pd.DataFrame:
+    """Coerce common Gradio Dataframe values into a Pandas DataFrame."""
+    if review_table is None:
+        return pd.DataFrame(columns=REVIEW_COLUMNS)
+    if isinstance(review_table, pd.DataFrame):
+        return review_table.reindex(columns=REVIEW_COLUMNS)
+    if isinstance(review_table, list):
+        return pd.DataFrame(review_table, columns=REVIEW_COLUMNS)
+    if isinstance(review_table, dict) and "data" in review_table:
+        headers = review_table.get("headers") or REVIEW_COLUMNS
+        return pd.DataFrame(review_table["data"], columns=headers).reindex(columns=REVIEW_COLUMNS)
+    return pd.DataFrame(review_table).reindex(columns=REVIEW_COLUMNS)
+
+
+def _clean_record(record: dict[str, Any]) -> dict[str, Any]:
+    """Normalize editable table values before Pydantic validation."""
+    cleaned = dict(record)
+    for field in ["item", "customer", "notes"]:
+        cleaned[field] = _none_if_blank(cleaned.get(field))
+
+    for field in ["quantity", "unit_price", "amount", "confidence"]:
+        cleaned[field] = _number_or_none(cleaned.get(field))
+
+    cleaned["transaction_type"] = _none_if_blank(cleaned.get("transaction_type")) or "unknown"
+    cleaned["payment_status"] = _none_if_blank(cleaned.get("payment_status")) or "unknown"
+    cleaned["notes"] = cleaned["notes"] or ""
+    cleaned["confidence"] = cleaned["confidence"] if cleaned["confidence"] is not None else 0.0
+    return cleaned
+
+
+def _none_if_blank(value: Any) -> Any:
+    """Return None for blank, null, or NaN values."""
+    if value is None:
+        return None
+    if pd.isna(value):
+        return None
+    if isinstance(value, str) and not value.strip():
+        return None
+    if isinstance(value, str):
+        return value.strip()
+    return value
+
+
+def _number_or_none(value: Any) -> float | None:
+    """Return a float for numeric values, otherwise None."""
+    normalized = _none_if_blank(value)
+    if normalized is None:
+        return None
+    return float(normalized)
+
+
+def _is_empty_record(record: dict[str, Any]) -> bool:
+    """Return whether a review row has no meaningful transaction data."""
+    return (
+        record["transaction_type"] == "unknown"
+        and record["item"] is None
+        and record["amount"] is None
+        and record["customer"] is None
+        and not record["notes"]
+    )

voiceledger/parser/rules.py

@@ -26,6 +26,17 @@ EXPENSE_PATTERN = re.compile(
     rf"(?P<item>[a-zA-Z][a-zA-Z\s-]*)?",
     re.IGNORECASE,
 )
+SHORTHAND_SALE_PATTERN = re.compile(
+    rf"^\s*(?P<item>[a-zA-Z][a-zA-Z\s-]*?)\s+"
+    rf"(?P<quantity>\d+(?:\.\d+)?)\s*(?:x|@)\s*"
+    rf"(?P<unit_price>\d+(?:\.\d+)?)\s*$",
+    re.IGNORECASE,
+)
+SHORTHAND_EXPENSE_PATTERN = re.compile(
+    rf"^\s*(?P<item>[a-zA-Z][a-zA-Z\s-]*?)\s+"
+    rf"(?P<amount>\d+(?:\.\d+)?)\s*$",
+    re.IGNORECASE,
+)
 INVENTORY_PURCHASE_PATTERN = re.compile(
     rf"\b(?:bought|purchased|buy|stocked|restocked)\s+"
     rf"(?P<quantity>\d+(?:\.\d+)?)\s+"
@@ -81,10 +92,18 @@ def parse_transaction(note: str) -> Transaction:
     if sale:
         return sale
 
+    shorthand_sale = _parse_shorthand_sale(cleaned_note)
+    if shorthand_sale:
+        return shorthand_sale
+
     expense = _parse_expense(cleaned_note)
     if expense:
         return expense
 
+    shorthand_expense = _parse_shorthand_expense(cleaned_note)
+    if shorthand_expense:
+        return shorthand_expense
+
     return Transaction(notes=cleaned_note, confidence=0.15)
 
 
@@ -132,6 +151,42 @@ def _parse_expense(note: str) -> Transaction | None:
     )
 
 
+def _parse_shorthand_sale(note: str) -> Transaction | None:
+    """Parse notes like 'mango 12 x 20'."""
+    match = SHORTHAND_SALE_PATTERN.search(note)
+    if not match:
+        return None
+
+    quantity = _to_float(match.group("quantity"))
+    unit_price = _to_float(match.group("unit_price"))
+    return Transaction(
+        transaction_type="sale",
+        item=_clean_item(match.group("item")),
+        quantity=quantity,
+        unit_price=unit_price,
+        amount=round(quantity * unit_price, 2) if quantity is not None and unit_price is not None else None,
+        payment_status="paid",
+        notes=note,
+        confidence=0.82,
+    )
+
+
+def _parse_shorthand_expense(note: str) -> Transaction | None:
+    """Parse notes like 'rent 300'."""
+    match = SHORTHAND_EXPENSE_PATTERN.search(note)
+    if not match:
+        return None
+
+    return Transaction(
+        transaction_type="expense",
+        item=_clean_item(match.group("item")),
+        amount=_to_float(match.group("amount")),
+        payment_status="paid",
+        notes=note,
+        confidence=0.68,
+    )
+
+
 def _parse_inventory_purchase(note: str) -> Transaction | None:
     """Parse notes like 'Bought 50 mangoes'."""
     match = INVENTORY_PURCHASE_PATTERN.search(note)

voiceledger/ui/gradio_app.py

@@ -19,6 +19,7 @@ from voiceledger.ledger.analytics import (
 from voiceledger.ledger.customers import get_customer_balances
 from voiceledger.ledger.database import add_transaction, get_transactions, initialize_database
 from voiceledger.ledger.inventory import get_inventory
+from voiceledger.parser.bulk import REVIEW_COLUMNS, parse_bulk_notes, review_table_to_transactions
 from voiceledger.parser.rules import parse_transaction
 from voiceledger.parser.schema import Transaction
 from voiceledger.reports.pdf_report import generate_daily_summary_pdf
@@ -82,6 +83,33 @@ def create_app(db_path: str | Path | None = None) -> gr.Blocks:
                 outputs=status_output,
             )
 
+        with gr.Tab("Bulk Import"):
+            bulk_notes_input = gr.Textbox(
+                label="Paste transaction notes",
+                placeholder="mango 12 x 20\nrent 300\nAmit owes 100\nRamesh paid 50",
+                lines=8,
+            )
+            with gr.Row():
+                bulk_parse_button = gr.Button("Parse Lines", variant="primary")
+                bulk_save_button = gr.Button("Save All Transactions")
+            bulk_review_output = gr.Dataframe(
+                headers=REVIEW_COLUMNS,
+                label="Review and edit transactions",
+                interactive=True,
+                wrap=True,
+            )
+            bulk_status_output = gr.Markdown()
+            bulk_parse_button.click(
+                fn=_parse_bulk_notes_for_review,
+                inputs=bulk_notes_input,
+                outputs=[bulk_review_output, bulk_status_output],
+            )
+            bulk_save_button.click(
+                fn=lambda review_table: _save_bulk_transactions(review_table, db_path),
+                inputs=bulk_review_output,
+                outputs=bulk_status_output,
+            )
+
         with gr.Tab("Dashboard"):
             refresh_dashboard_button = gr.Button("Refresh Dashboard", variant="primary")
             with gr.Row():
@@ -261,6 +289,28 @@ def _save_transaction(transaction_payload: dict[str, Any] | None, db_path: str |
     return f"Saved transaction #{transaction_id}."
 
 
+def _parse_bulk_notes_for_review(notes: str) -> tuple[pd.DataFrame, str]:
+    """Parse pasted multiline notes into an editable review table."""
+    review_table = parse_bulk_notes(notes)
+    if review_table.empty:
+        return review_table, "Paste one transaction per line, then parse."
+    return review_table, f"Parsed {len(review_table)} transaction lines. Review and edit before saving."
+
+
+def _save_bulk_transactions(review_table: Any, db_path: str | Path | None) -> str:
+    """Save all reviewed bulk import transactions."""
+    try:
+        transactions = review_table_to_transactions(review_table)
+    except Exception as exc:
+        return f"Could not save bulk import: {exc}"
+
+    if not transactions:
+        return "No reviewed transactions to save."
+
+    saved_ids = [add_transaction(transaction, db_path) for transaction in transactions]
+    return f"Saved {len(saved_ids)} transactions. Last transaction id: #{saved_ids[-1]}."
+
+
 def _get_dashboard_data(
     db_path: str | Path | None,
 ) -> tuple[float, float, float, float, str, pd.DataFrame, pd.DataFrame]: