monopyly 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

monopyly/CHANGELOG.md

@@ -207,7 +207,34 @@
 - Return to statement details page after deleting a transaction (rather than returning to the general transactions page)
 - Allow users to change their password
 - Warn users before form submission if the configuration currently disallows registration
+- Fix issues with the application launcher not launching the browser; couple application launch process more tightly with click
+- Use type annotations for SQLAlchemy ORM declarative mappings
 - Increase the flexibility of the credit activity parser
 
 
+### 1.5.2
+
+- Use smoothing on charts for up to 100 transactions
+- Improve tokenization normalization for credit reconciliation
+- Remove statement requiring activity files be located in the `Downloads` directory
+- Do not clear the reconciliation info when adding subtransaction fields via POST request
+- Incorporate support for enhanced database handler selection subsets
+- Bump dependencies (including support for recent SQLAlchemy versions)
+
+
+### 1.6.0
+
+- Enable additional transactions to be loaded on bank/credit transactions tables
+- Create a script to take application screenshots (e.g., for the 'About' page)
+- Remove Python version requirement (allow Python versions after 3.10)
+- Use Jinja recursive loops for transaction tag tree structures in templates
+- Refactor to include ruff-based linting checks
+- Set 'Credit payments' to be a default tag for all users
+- Protect globally defined tags from user deletion
+- Hide transaction tags when the Escape key is pressed
+- Ensure that the 'Record Transfer' functionality only ever adds one input box
+- Update dependencies (including using ruff in place of _Black_ and _isort_)
+- Update JavaScript libraries (jQuery, Chartist)
+
+
 <a name="bottom" id="bottom"></a>

monopyly/README.md

@@ -27,10 +27,10 @@ The package requires a recent version of Python (3.10+).
 
 ## Getting started
 
-Once the package is properly installed, run the app in local mode from the command line (the default options should be sensible, but you may customize the host and port if necessary):
+Once the package is properly installed, launch the app in local mode from the command line (the default options should be sensible, but you may customize the host and port if necessary):
 
 ```
-$ monopyly local --browser [--host HOST] [--port PORT]
+$ monopyly launch local --browser [--host HOST] [--port PORT]
 ```
 
 Local mode indicates that the app is just going to be run using a locally hosted server, accessible to just your machine.
@@ -123,7 +123,7 @@ Card balances are also visible by visiting the pages for individual statements.
 A full history of statements for each card is available off the homepage.
 Each statement's page gives the statement's balance, transactions, and due date.
 
-<img class="screenshot" src="monopyly/static/img/about/statement-details.png" alt="statement details" width="800px" />
+<img class="screenshot" src="monopyly/static/img/about/credit-statement-details.png" alt="statement details" width="800px" />
 
 Payments can be made directly from a statement's page and can be linked to a bank account in the _Monopyly_ system for simplified tracking.
 (Note that even linked transactions must be edited independently, as there are times when a user may wish to have separate values for linked transactions. For example, a credit card payment may be processed on a given date while it is only registered as a bank account transaction several days later.)

monopyly/__init__.py

@@ -2,39 +2,29 @@
 Run the Monopyly app.
 """
 
-from flask import Flask
+from dry_foundation import DryFlask, Factory, interact
 
-from monopyly.config import DevelopmentConfig, ProductionConfig
-from monopyly.core.errors import render_error_template
-from monopyly.database import SQLAlchemy, register_db_cli_commands
+from .core.errors import render_error_template
+from .database import SQLAlchemy
 
 
-def create_app(test_config=None, debug=None):
-    # Create and configure the app
-    app = Flask(__name__, instance_relative_config=True)
-
-    # Prepare the app configuration
-    if test_config:
-        config = test_config
-    else:
-        # Load the development/production config when not testing
-        if app.debug or debug:
-            config = DevelopmentConfig.configure_for_instance(app.instance_path)
-        else:
-            config = ProductionConfig.configure_for_instance(app.instance_path)
-    app.config.from_object(config)
-
-    # Initialize the app, including CLI commands and blueprints
-    init_app(app)
-    return app
-
+@Factory(db_interface=SQLAlchemy, echo_engine=False)
+def create_app(config=None):
+    """
+    Create the Flask application.
 
-@SQLAlchemy.interface_selector
-def init_app(app):
-    """Initialize the app."""
+    Create the Flask app, including configurations as specified. This
+    will configure the app using the configuration objects made
+    available by the Monopyly application and initialize the app
+    by registering app blueprints, routes, and commands.
+    """
+    # Create and configure the app
+    app = DryFlask(__name__, app_name="Monopyly")
+    app.configure(config)
+    # Register blueprints and error handlers specific to this app
     register_blueprints(app)
     register_errorhandlers(app)
-    register_db_cli_commands(app)
+    return app
 
 
 def register_blueprints(app):
@@ -76,3 +66,8 @@ def register_errorhandlers(app):
     ]
     for code in handled_error_codes:
         app.register_error_handler(code, render_error_template)
+
+
+def main():
+    """The entry point to the Monopyly application."""
+    interact(__name__)

monopyly/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.5.1'
-__version_tuple__ = version_tuple = (1, 5, 1)
+__version__ = version = '1.6.0'
+__version_tuple__ = version_tuple = (1, 6, 0)

monopyly/auth/blueprint.py

@@ -9,3 +9,5 @@ bp = Blueprint("auth", __name__, url_prefix="/auth")
 
 # Import routes after defining blueprint to avoid circular imports
 from . import routes
+
+__all__ = ["routes"]

monopyly/auth/routes.py

@@ -2,6 +2,7 @@
 Routes for site authentication.
 """
 
+from dry_foundation.database import db_transaction
 from flask import (
     current_app,
     flash,
@@ -12,8 +13,6 @@ from flask import (
     session,
     url_for,
 )
-from fuisce.database import db_transaction
-from sqlalchemy import select
 from werkzeug.security import check_password_hash, generate_password_hash
 
 from ..database.models import User
@@ -34,7 +33,7 @@ def register():
             error = "Username is required."
         elif not password:
             error = "Password is required."
-        elif user := identify_user(username):
+        elif identify_user(username):
             error = f"User {username} is already registered."
         else:
             # Create a new user

monopyly/banking/accounts.py

@@ -3,8 +3,8 @@ Tools for interacting with bank accounts in the database.
 """
 
 import sqlalchemy.sql.functions as sql_func
-from authanor.database.handler import DatabaseViewHandler
-from werkzeug.exceptions import abort
+from dry_foundation.database.handler import DatabaseViewHandler
+from flask import abort
 
 from ..common.forms.utils import execute_on_form_validation
 from ..database.models import (
@@ -114,15 +114,15 @@ class BankAccountTypeHandler(
         super().delete_entry(entry_id)
 
     @classmethod
-    def _validate_authorization(cls, entry_id):
-        account_type = super()._validate_authorization(entry_id)
-        # Limit manipulation to only the user (excluding common entries)
+    def _retrieve_authorized_manipulable_entry(cls, entry_id):
+        account_type = super()._retrieve_authorized_manipulable_entry(entry_id)
         if account_type.user_id != cls.user_id:
             abort_msg = (
                 "The current user is not authorized to manipulate "
                 "this account type entry."
             )
             abort(403, abort_msg)
+        return account_type
 
 
 class BankAccountHandler(
@@ -229,10 +229,10 @@ class BankAccountHandler(
         return account
 
     @classmethod
-    def _filter_entries(cls, query, criteria):
+    def _filter_entries(cls, query, criteria, offset, limit):
         # Add a join to enable filtering by bank account type
         query = query.join(BankAccountTypeView)
-        return super()._filter_entries(query, criteria)
+        return super()._filter_entries(query, criteria, offset, limit)
 
     @classmethod
     def delete_entry(cls, entry_id):

monopyly/banking/actions.py

@@ -1,6 +1,6 @@
 """Module describing logical banking actions (to be used in routes)."""
 
-from collections import UserList, namedtuple
+from collections import UserDict, namedtuple
 
 from ..common.utils import convert_date_to_midnight_timestamp
 from .accounts import BankAccountHandler, BankAccountTypeHandler
@@ -30,25 +30,26 @@ def get_balance_chart_data(transactions):
 
     Returns
     -------
-    chart_data : list
-        A list containing (x, y) pairs, each consisting of the Unix
+    chart_data : dict
+        A dictionary containing a Chartist compatible data structure,
+        including (x, y) pairs that each represent the Unix
         timestamp (in milliseconds) and the bank account balance.
     """
-    return list(_BalanceChartData(transactions))
+    return _BalanceChartData(transactions).data
 
 
-class _BalanceChartData(UserList):
+class _BalanceChartData(UserDict):
     """
-    A list of balances to be passed to a `chartist.js` chart constructor.
+    A mapping of balances to be passed to a `chartist.js` chart constructor.
 
-    A special list-like object containing transaction data formatted for
-    use in a balance chart created by the `chartist.js` library. This
-    converts each transaction into an (x, y) pair consisting of a Unix
-    timestamp (in milleseconds) and a corresponding bank account
-    balance. For transactions occurring on the same day (the finest
-    granularity recorded by the Monopyly app), a slight offset is
-    added to each timestamp to guarantee a smooth representation in the
-    rendered chart.
+    A special dictionary-like object containing transaction data
+    formatted for use in a balance chart created by the `chartist.js`
+    library. This converts each transaction into an (x, y) pair
+    consisting of a Unix timestamp (in milleseconds) and a corresponding
+    bank account balance. For transactions occurring on the same day
+    (the finest granularity recorded by the Monopyly app), a slight
+    offset is added to each timestamp to guarantee a smooth
+    representation in the rendered chart.
 
     Parameters
     ----------
@@ -61,9 +62,9 @@ class _BalanceChartData(UserList):
     point = namedtuple("DataPoint", ["timestamp", "balance"])
 
     def __init__(self, transactions):
-        super().__init__()
         transaction_groups = self._group_transactions_by_date(transactions)
-        self._prepare_chart_data(transaction_groups)
+        chart_data = self._prepare_chart_data(transaction_groups)
+        super().__init__({"series": [{"name": "balances", "data": chart_data}]})
 
     @staticmethod
     def _group_transactions_by_date(transactions):
@@ -75,6 +76,7 @@ class _BalanceChartData(UserList):
 
     def _prepare_chart_data(self, transaction_groups):
         # Assign chart data to the list as tuples, adding offsets for duplicated dates
+        chart_data = []
         for transaction_date, transaction_group in transaction_groups.items():
             base_timestamp = convert_date_to_midnight_timestamp(
                 transaction_date, milliseconds=True
@@ -82,4 +84,5 @@ class _BalanceChartData(UserList):
             offset = self._DAILY_MILLISECONDS / len(transaction_group)
             for i, transaction in enumerate(transaction_group):
                 adjusted_timestamp = base_timestamp + (i * offset)
-                self.data.append((adjusted_timestamp, transaction.balance))
+                chart_data.append({"x": adjusted_timestamp, "y": transaction.balance})
+        return chart_data

monopyly/banking/banks.py

@@ -2,7 +2,7 @@
 Tools for interacting with banks in the database.
 """
 
-from authanor.database.handler import DatabaseHandler
+from dry_foundation.database.handler import DatabaseHandler
 
 from ..database.models import Bank
 

monopyly/banking/blueprint.py

@@ -9,3 +9,5 @@ bp = Blueprint("banking", __name__, url_prefix="/banking")
 
 # Import routes after defining blueprint to avoid circular imports
 from . import filters, routes
+
+__all__ = ["filters", "routes"]

monopyly/banking/filters.py

@@ -6,14 +6,14 @@ from .blueprint import bp
 
 
 @bp.app_template_filter("is_single_bank_transfer")
-def check_transfer_is_within_bank(transaction):
-    """Check if the transfer is linked ot another transaction at the same bank."""
-    if transaction.internal_transaction:
-        linked_bank_transactions = transaction.internal_transaction.bank_transactions
+def check_transfer_is_within_bank(transaction_view):
+    """Check if the transfer is linked to another transaction at the same bank."""
+    if internal_transaction := transaction_view.internal_transaction:
+        linked_bank_transactions = internal_transaction.bank_transaction_views
         if len(linked_bank_transactions) > 1:
-            common_bank_id = linked_bank_transactions[0].account.bank_id
+            common_bank_id = linked_bank_transactions[0].account_view.bank_id
             return all(
-                transaction.account.bank_id == common_bank_id
+                transaction.account_view.bank_id == common_bank_id
                 for transaction in linked_bank_transactions
             )
     return False

monopyly/banking/forms.py

@@ -2,18 +2,16 @@
 Generate banking forms for the user to complete.
 """
 
-from wtforms.fields import BooleanField, FieldList, FormField, StringField, SubmitField
+from wtforms.fields import BooleanField, FieldList, FormField, SubmitField
 from wtforms.validators import DataRequired, Optional
 
 from ..common.forms import AcquisitionSubform, EntryForm, EntrySubform, TransactionForm
 from ..common.forms.fields import (
     CustomChoiceSelectField,
-    DateField,
     LastFourDigitsField,
     StringField,
 )
 from ..common.forms.utils import Autocompleter
-from ..common.utils import parse_date
 from ..database.models import (
     Bank,
     BankAccountTypeView,
@@ -179,7 +177,7 @@ class BankTransactionForm(TransactionForm):
                 data = {
                     "bank_name": entry.bank.bank_name,
                     "last_four_digits": entry.last_four_digits,
-                    "type_name": entry.account_type.type_name,
+                    "type_name": entry.account_type_view.type_name,
                 }
             elif isinstance(entry, Bank):
                 data = {"bank_name": entry.bank_name}
@@ -278,7 +276,7 @@ class BankTransactionForm(TransactionForm):
         """Gather data for the form from the given database entry."""
         if isinstance(entry, BankTransactionView):
             data = self._gather_transaction_data(entry)
-            account_info = entry.account
+            account_info = entry.account_view
             # Do not prepopulate any transfer information
         elif isinstance(entry, (BankAccountView, Bank)):
             data = {}

monopyly/banking/routes.py

@@ -2,8 +2,8 @@
 Routes for banking financials.
 """
 
-from flask import jsonify, redirect, render_template, request, url_for
-from fuisce.database import db_transaction
+from dry_foundation.database import db_transaction
+from flask import g, jsonify, redirect, render_template, request, url_for
 
 from ..auth.tools import login_required
 from ..common.forms.utils import extend_field_list_for_ajax
@@ -13,7 +13,10 @@ from .actions import get_balance_chart_data, get_bank_account_type_grouping
 from .banks import BankHandler
 from .blueprint import bp
 from .forms import BankAccountForm, BankTransactionForm
-from .transactions import BankTransactionHandler, save_transaction
+from .transactions import BankTagHandler, BankTransactionHandler, save_transaction
+
+# Set a limit on the number of transactions loaded at one time for certain routes
+TRANSACTION_LIMIT = 100
 
 
 @bp.route("/accounts")
@@ -34,7 +37,7 @@ def add_account(bank_id):
     form = BankAccountForm()
     # Check if an account was submitted and add it to the database
     if request.method == "POST":
-        account = save_account(form)
+        save_account(form)
         return redirect(url_for("banking.load_accounts"))
     else:
         if bank_id:
@@ -69,21 +72,39 @@ def load_account_summaries(bank_id):
 @login_required
 def load_account_details(account_id):
     account = BankAccountHandler.get_entry(account_id)
-    transactions = list(
-        BankTransactionHandler.get_transactions(
-            account_ids=(account_id,), sort_order="DESC"
-        )
-    )
+    transactions = BankTransactionHandler.get_transactions(
+        account_ids=(account_id,), sort_order="DESC"
+    ).all()
     # Only display the first 100 transactions
     return render_template(
         "banking/account_page.html",
         account=account,
-        account_transactions=transactions[:100],
+        transactions=transactions[:100],
+        total_transactions=len(transactions),
         # Reverse the chart transactions to be chronologically ascending
         chart_data=get_balance_chart_data(reversed(transactions)),
     )
 
 
+@bp.route("/_extra_transactions", methods=("POST",))
+@login_required
+def load_more_transactions():
+    # Get info about the transactions being displayed from the AJAX request
+    post_args = request.get_json()
+    account_id = post_args["account_id"]
+    block_index = post_args["block_count"] - 1
+    # Get a subset of the remaining transactions to load
+    more_transactions = BankTransactionHandler.get_transactions(
+        account_ids=(account_id,),
+        offset=block_index * TRANSACTION_LIMIT,
+        limit=TRANSACTION_LIMIT,
+    )
+    return render_template(
+        "banking/transactions_table/transactions.html",
+        transactions=more_transactions,
+    )
+
+
 @bp.route("/_expand_transaction", methods=("POST",))
 @login_required
 def expand_transaction():
@@ -216,6 +237,47 @@ def delete_transaction(transaction_id):
     return redirect(url_for("banking.load_account_details", account_id=account_id))
 
 
+@bp.route("/tags")
+@login_required
+def load_tags():
+    # Get the tag hierarchy from the database
+    hierarchy = BankTagHandler.get_hierarchy()
+    return render_template("common/tags_page.html", tags_hierarchy=hierarchy)
+
+
+@bp.route("/_add_tag", methods=("POST",))
+@login_required
+@db_transaction
+def add_tag():
+    # Get the new tag (and potentially parent category) from the AJAX request
+    post_args = request.get_json()
+    tag_name = post_args["tag_name"]
+    parent_name = post_args.get("parent")
+    # Check that the tag name does not already exist
+    if BankTagHandler.get_tags(tag_names=(tag_name,)):
+        raise ValueError("The given tag name already exists. Tag names must be unique.")
+    parent_id = BankTagHandler.find_tag(parent_name).id if parent_name else None
+    tag = BankTagHandler.add_entry(
+        parent_id=parent_id,
+        user_id=g.user.id,
+        tag_name=tag_name,
+    )
+    return render_template("common/tag_tree.html", tags_hierarchy={tag: []})
+
+
+@bp.route("/_delete_tag", methods=("POST",))
+@login_required
+@db_transaction
+def delete_tag():
+    # Get the tag to be deleted from the AJAX request
+    post_args = request.get_json()
+    tag_name = post_args["tag_name"]
+    tag = BankTagHandler.find_tag(tag_name)
+    # Remove the tag from the database
+    BankTagHandler.delete_entry(tag.id)
+    return ""
+
+
 @bp.route("/_suggest_transaction_autocomplete", methods=("POST",))
 @login_required
 def suggest_transaction_autocomplete():

monopyly/banking/transactions.py

@@ -2,13 +2,12 @@
 Tools for interacting with the bank transactions in the database.
 """
 
-from authanor.database.handler import DatabaseViewHandler
+from dry_foundation.database.handler import DatabaseViewHandler
 
 from ..common.forms.utils import execute_on_form_validation
 from ..common.transactions import TransactionHandler, TransactionTagHandler
 from ..core.internal_transactions import add_internal_transaction
 from ..database.models import (
-    Bank,
     BankAccountView,
     BankSubtransaction,
     BankTransaction,
@@ -36,7 +35,9 @@ class BankTransactionHandler(
 
     @classmethod
     @DatabaseViewHandler.view_query
-    def get_transactions(cls, account_ids=None, active=None, sort_order="DESC"):
+    def get_transactions(
+        cls, account_ids=None, active=None, sort_order="DESC", offset=None, limit=None
+    ):
         """
         Get bank transactions from the database.
 
@@ -61,6 +62,13 @@ class BankTransactionHandler(
             An indicator of whether the transactions should be ordered
             in ascending (oldest at top) or descending (newest at top)
             order. The default is descending order.
+        offset : int, optional
+            The number of transactions by which to offset the results
+            returned by this query. The default is `None`, in which case
+            no offset will be added.
+        limit : int, optional
+            A limit on the number of transactions retrieved from the
+            database.
 
         Returns
         -------
@@ -71,7 +79,7 @@ class BankTransactionHandler(
         criteria.add_match_filter(cls.model, "account_id", account_ids)
         criteria.add_match_filter(BankAccountView, "active", active)
         transactions = super()._get_transactions(
-            criteria=criteria, sort_order=sort_order
+            criteria=criteria, sort_order=sort_order, offset=offset, limit=limit
         )
         return transactions
 
@@ -150,7 +158,7 @@ class BankTagHandler(TransactionTagHandler, model=TransactionTagHandler.model):
         return tags
 
     @classmethod
-    def _filter_entries(cls, query, criteria):
+    def _filter_entries(cls, query, criteria, offset, limit):
         # Add a join to enable filtering by transaction ID or subtransaction ID
         join_transaction = BankTransactionView in criteria.discriminators
         join_subtransaction = (
@@ -160,7 +168,7 @@ class BankTagHandler(TransactionTagHandler, model=TransactionTagHandler.model):
             query = query.join(bank_tag_link_table).join(BankSubtransaction)
             if join_transaction:
                 query = query.join(BankTransactionView)
-        return super()._filter_entries(query, criteria)
+        return super()._filter_entries(query, criteria, offset, limit)
 
 
 @execute_on_form_validation
@@ -205,7 +213,7 @@ def save_transaction(form, transaction_id=None):
             transfer = record_new_transfer(transfer_data)
             transaction_data.update(
                 internal_transaction_id=transfer.internal_transaction_id,
-                merchant=transfer.account.bank.bank_name,
+                merchant=transfer.account_view.bank.bank_name,
             )
         transaction = BankTransactionHandler.add_entry(**transaction_data)
     return transaction

monopyly/common/forms/__init__.py

@@ -5,3 +5,11 @@ from ._forms import (
     TransactionForm,
     form_err_msg,
 )
+
+__all__ = [
+    "AcquisitionSubform",
+    "EntryForm",
+    "EntrySubform",
+    "TransactionForm",
+    "form_err_msg",
+]

monopyly/common/forms/_forms.py

@@ -6,11 +6,10 @@ from abc import ABC, abstractmethod
 from datetime import date
 
 from flask_wtf import FlaskForm
-from wtforms.fields import FieldList, FormField, SelectField, StringField, SubmitField
+from wtforms.fields import StringField, SubmitField
 from wtforms.validators import DataRequired
 
 from .fields import CurrencyField, DateField
-from .validators import SelectionNotBlank
 
 # Define a custom form error messaage
 form_err_msg = "There was an improper value in your form. Please try again."

monopyly/common/forms/fields.py

@@ -4,12 +4,10 @@ General form constructions.
 
 from abc import ABC, abstractmethod
 
-from flask_wtf import FlaskForm
 from wtforms import fields as wtforms_fields
 from wtforms.validators import Length
 from wtforms.widgets import NumberInput
 
-from ...banking.banks import BankHandler
 from ..utils import parse_date
 from .validators import NumeralsOnly, SelectionNotBlank
 

monopyly/common/forms/utils.py

@@ -75,7 +75,7 @@ class Autocompleter:
         # Get information from the database to use for autocompletion
         query = model.select_for_user(getattr(model, field))
         values = current_app.db.session.scalars(query)
-        suggestions = sort_by_frequency([value for value in values])
+        suggestions = sort_by_frequency(list(values))
         return suggestions
 
     def _sort_suggestions_by_field(