monopyly 1.4.6__py3-none-any.whl → 1.4.8__py3-none-any.whl

monopyly/CHANGELOG.md

@@ -0,0 +1,195 @@
+# Changelog
+
+<a class="latest-release" href="#bottom">Latest</a>
+
+## 1.0.0
+
+- Initial release
+
+
+### 1.0.1
+
+- Added dependencies to `setup.py` for self-contained installation
+- Added this changelog
+- Added a generally comprehensive [README](README.md)
+- Fixed a few minor bugs with the display interface
+
+
+### 1.0.2
+
+- Added image support to PyPI description
+
+
+### 1.0.3
+
+- Implemented (rudimentary) interface for adding and removing transaction tags
+- Added button to add more statements to a transaction (from submission complete page)
+- Fixed bug in updating a transaction's statement date to a new statement
+- Fixed bug where tags where not saved on new transactions
+
+
+### 1.0.4
+
+- Improved tagging interface with a 'Manage Tags' page
+- Introduced statement level statistics
+- Renamed database files to end with `.sqlite` extension
+- Moved menus on 'Statement Details' and 'Account Details' pages into the sidebar to prevent overlap on collapsed screens
+- Renamed `show_*` route functions to `load_*` to clarify that they are for loading the associated pages (as opposed to just displaying content)
+
+
+### 1.0.5
+
+- Transactions may be split into an arbitrary number of subtransactions, each with a separate subtotal and note
+- Backend properly handles duplicate/ancestor tags; all tags are saved in the database, but only the lowest-level child tag must be entered
+- Removed statement level statistics display (not yet mature)
+
+
+## 1.1.0
+
+- Added banking interface
+- Added interface for displaying linked transactions (including between bank transactions and credit transactions)
+- Grayed out pending transactions
+- Fixed bug where transaction tags appeared in front of header bar
+- Improved modularity of autocomplete JavaScript
+- Improved modularity of transaction table templates (for banking and credit transactions)
+- Minor cosmetic enhancements
+
+
+## 1.2.0
+
+- Database backend converted to use SQLAlchemy (2.0)
+- Complete test suite created
+- Banking interface updated to use subtransactions
+- Added the ability to transfer statements when a new credit card is added to an account
+- Fixed error on handling subtransactions in credit forms
+- Fixed error updating transaction display from widget bar
+
+
+### 1.2.1
+
+- Improve development functionality; better/safer cleaning with a separate database and preloaded data
+- Add custom form fields for consistent app-wide form implementations
+- Overhaul documentation formatting with _isort_ and _Black_
+- Fixed bug where multiple subtransactions failed to update properly
+- Fixed error where validation was not raised for blank inputs to a `CustomChoiceSelectField`
+- Fixed errors in field validation for nested subforms with unset values
+
+
+### 1.2.2
+
+- Use `pyproject.toml` via Hatch
+- Added version information to app footer
+- Fixed bug where bank name failed to show on 'Credit Account Details' page
+- Improved JavaScript management for acquisition forms
+
+
+### 1.2.3
+
+- Add currency symbol to the amount field(s)
+- Allow subform fields to be removed from forms
+- Change 'Vendor' field name to 'Merchant' for better generalizability
+- Remove wildcard imports from the package source code
+- Update form styles to be more browser compatible
+- Impose boolean constraint on boolean/integer database fields
+- Use metaclasses for database handler to avoid stacking classmethod and property (deprecated in Python 3.11)
+
+
+## 1.3.0
+
+- Add a merchant field and tags to bank transactions
+- Add an enhanced autocompletion for assigning transaction tags
+- Add a settings page for allowing bank names to be changed (and eventually allowing passwords to be updated, among other functionality)
+- Leverage SQLAlchemy 2.0 `DeclarativeBase` class and `declared_attr` decorators
+- Simplify `Model` base to avoid explicitly defining column attributes
+- Update the database backup script to work as part of the package
+- Swap the README instructions for the 'About' page (and move the story to a separate page)
+- Improve utilization of `pyroject.toml`
+- Factor out the database handlers (now found in the Authanor package dependency)
+
+
+### 1.3.1
+
+- Upgrade jQuery version to 3.7.0
+- Use recommended `importlib` method for pytest
+- Automatically use the transferring bank as the merchant in bank transfers
+- For transfers between accounts at the same bank, do not show 'Withdrawal' or 'Deposit' headers; just mark as 'Transfer'
+
+
+## 1.4.0
+
+- Add charts showing historical balances to bank account details page
+- Show projected balances for bank transactions occurring in the future
+- Allow users to remove the welcome block from the homepage
+- Make use of `data-*` HTML tag attributes rather than ID parsing
+- Prevent JavaScript errors on statement pages when buttons are non-existent
+- Clean up transaction table overflow for transaction notes
+- Generalize transaction forms using Jinja `super` blocks
+- Convert JavaScript files to be named using kebab case
+- Use Fuisce in place of Authanor for db/testing interfaces
+
+
+### 1.4.1
+
+- Use local time for determining projected balances
+- Show future credit statement payments as "scheduled" (and improve logic for displaying paid notices)
+- Fix incorrect return type in `CreditStatementHandler.infer_statement` method
+- Distinguish between inline code and "fenced" code using a Markdown library extension
+- Use more `data-*` attributes for processing transaction IDs
+- Fix bug where linked transactions did not use jQuery reference
+
+
+### 1.4.2
+
+- Configure production mode via Gunicorn
+- Standardize CLI usage messages
+- Make browser usage optional in CLI run script
+
+
+### 1.4.3
+
+- Reconfigure makefile for smoother installation
+- Fix bug where transaction toggling failed on filter updates
+
+
+### 1.4.4
+
+- Update date-to-timestamp conversion to be timezone invariant
+- Fix database initialization for development mode
+- Fix bug where credit card number was not displayed in card summary
+- Use Beautiful Soup to make tests more robust
+
+
+### 1.4.5
+
+- Fix bug where a transaction for a new statement was marked as invalid on entry
+- Sort bank account displays by account type and last four digits
+- Use SQLAlchemy 'selectin' loading mode for commonly loaded relationships
+- Give tags a property for identifying their depth in the user's "tag tree"
+
+
+### 1.4.6
+
+- Bump dependencies (including patching security vulnerability in gunicorn)
+- Add a function for acquiring a statement and all of its transactions
+- Add a convenience method to the statement handler for getting the preceding statement
+
+
+### 1.4.7
+
+- Create custom error pages for error responses (400, 404, 500, etc.)
+- Render the changelog and show it via the app
+- Display bank account type subtotals on the bank account summaries page
+- Set the current date as the default for transaction form inputs
+- Use the `strict` argument to the built-in `zip` function to strengthen tests
+- Refresh the table of transactions after making a payment on a credit card statement
+- Use SVG to handle long values in account/statement summary boxes; fixes bugs in page rendering (long value overflow) and hover actions not happening because of conflicting overlap with the sidebar
+
+
+### 1.4.8
+
+- Set username collection to be case insensitive
+- Use Flask/Gunicorn APIs (rather than subprocess CLI calls) to launch the app
+- Fix bug in the ordering of balances in the bank account balance charts for transactions on duplicate dates
+
+
+<a name="bottom" id="bottom"></a>

monopyly/README.md

@@ -22,17 +22,28 @@ To install the app, simply run
 $ pip install monopyly
 ```
 
-The package requires a recent version of Python (3.9+).
+The package requires a recent version of Python (3.10+).
 
 
 ## Getting started
 
-Once the package is properly installed, run the app 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, 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):
 
 ```
-$ monopyly development --browser [--host HOST] [--port PORT]
+$ monopyly 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.
+Other available modes are `development` and `production`, for those looking to either develop the application or host the application on a server.
+
+<div class="warning">
+  <h5>Use your brain when choosing a mode!</h5>
+  <small>
+    If you intend to be the only user of the app, served just from your PC, local mode is fine; you will be served well-enough by the built-in Python server, and you do not need to configure secret keys for the application.
+    If you plan to host the application, however, <b>DO NOT</b> use local mode (or development mode) and run the app in production mode instead.
+  </small>
+</div>
+
 By using the `--browser` option in development mode, this will open to an empty homepage with a welcome message.
 
 <img class="screenshot" src="monopyly/static/img/about/homepage.png" alt="user homepage" width="800px">

monopyly/__init__.py

@@ -1,10 +1,11 @@
 """
-Run a development server for the Monopyly app.
+Run the Monopyly app.
 """
 
 from flask import Flask
 
 from monopyly.config import DevelopmentConfig, ProductionConfig
+from monopyly.core.errors import render_error_template
 from monopyly.database import SQLAlchemy, register_db_cli_commands
 
 
@@ -32,6 +33,7 @@ def create_app(test_config=None):
 def init_app(app):
     """Initialize the app."""
     register_blueprints(app)
+    register_errorhandlers(app)
     register_db_cli_commands(app)
 
 
@@ -57,3 +59,20 @@ def register_blueprints(app):
     app.register_blueprint(auth_bp)
     app.register_blueprint(banking_bp)
     app.register_blueprint(credit_bp)
+
+
+def register_errorhandlers(app):
+    """Register error handlers with the app."""
+    handled_error_codes = [
+        400,
+        401,
+        403,
+        404,
+        405,
+        408,
+        418,
+        # 425 -- not yet supported
+        500,
+    ]
+    for code in handled_error_codes:
+        app.register_error_handler(code, render_error_template)

monopyly/_version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '1.4.6'
-__version_tuple__ = version_tuple = (1, 4, 6)
+__version__ = version = '1.4.8'
+__version_tuple__ = version_tuple = (1, 4, 8)

monopyly/auth/actions.py

@@ -2,7 +2,12 @@
 
 
 def get_username_and_password(form):
-    """Get username and password from a form."""
-    username = form["username"]
+    """
+    Get username and password from a form.
+
+    Get the username and password from the given form. Username should
+    be case insensitive.
+    """
+    username = form["username"].lower()
     password = form["password"]
     return username, password

monopyly/banking/accounts.py

@@ -122,7 +122,7 @@ class BankAccountTypeHandler(
                 "The current user is not authorized to manipulate "
                 "this account type entry."
             )
-            abort(404, abort_msg)
+            abort(403, abort_msg)
 
 
 class BankAccountHandler(

monopyly/banking/actions.py

@@ -1,5 +1,7 @@
 """Module describing logical banking actions (to be used in routes)."""
 
+from collections import UserList, namedtuple
+
 from ..common.utils import convert_date_to_midnight_timestamp
 from .accounts import BankAccountHandler, BankAccountTypeHandler
 
@@ -29,16 +31,55 @@ def get_balance_chart_data(transactions):
     Returns
     -------
     chart_data : list
-        A list of sorted (x, y) pairs consisting of the Unix timestamp
-        (in milliseconds) and the bank account balance.
+        A list containing (x, y) pairs, each consisting of the Unix
+        timestamp (in milliseconds) and the bank account balance.
+    """
+    return list(_BalanceChartData(transactions))
+
+
+class _BalanceChartData(UserList):
     """
-    chart_data = sorted(map(_make_transaction_balance_ordered_pair, transactions))
-    return chart_data
+    A list 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.
+
+    Parameters
+    ----------
+    transactions : list
+        A list of transactions to be used for generating the chart data.
+    """
+
+    _DAILY_MILLISECONDS = 86_400_000
+    offset = 1
+    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)
 
+    @staticmethod
+    def _group_transactions_by_date(transactions):
+        date_groups = {}
+        for transaction in transactions:
+            group = date_groups.setdefault(transaction.transaction_date, [])
+            group.append(transaction)
+        return date_groups
 
-def _make_transaction_balance_ordered_pair(transaction):
-    # Create an ordered pair of date (timestamp) and account balance
-    timestamp = convert_date_to_midnight_timestamp(
-        transaction.transaction_date, milliseconds=True
-    )
-    return timestamp, transaction.balance
+    def _prepare_chart_data(self, transaction_groups):
+        # Assign chart data to the list as tuples, adding offsets for duplicated dates
+        for transaction_date, transaction_group in transaction_groups.items():
+            base_timestamp = convert_date_to_midnight_timestamp(
+                transaction_date, milliseconds=True
+            )
+            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))

monopyly/banking/routes.py

@@ -79,7 +79,8 @@ def load_account_details(account_id):
         "banking/account_page.html",
         account=account,
         account_transactions=transactions[:100],
-        chart_data=get_balance_chart_data(transactions),
+        # Reverse the chart transactions to be chronologically ascending
+        chart_data=get_balance_chart_data(reversed(transactions)),
     )
 
 

monopyly/cli/apps.py

@@ -9,65 +9,88 @@ from .. import create_app
 
 
 class LocalApplication:
-    """An object for running the application locally."""
+    """
+    An object for running the application locally.
 
+    This application object will run the Flask application using the
+    built-in Python server on localhost, just like the Flask development
+    mode. However, it will launch from port 5001 to avoid conflicting
+    with other Python servers that may attempt to run on the default
+    port 5000.
+    """
+
+    mode_name = "local"
     default_port = "5001"
-    command = ["flask"]
+    _debug = None
 
     def __init__(self, host=None, port=None, **options):
         """Initialize the application in development mode."""
         self._host = host
-        self._port = port
+        self._port = port or self.default_port
         if options:
             raise NotImplementedError(
-                "Options besides `host` and `port` are not handled in development mode."
+                f"Options besides `host` and `port` are not handled in {self.mode_name} mode."
             )
+        self.application = create_app()
 
     def run(self):
         """Run the Monopyly application in development mode."""
-        instruction = self.command + ["run"]
-        if self._host:
-            instruction += ["--host", self._host]
-        if self._port:
-            instruction += ["--port", self._port]
-        server = subprocess.Popen(instruction)
+        self.application.run(
+            host=self._host,
+            port=self._port,
+            debug=self._debug,
+        )
 
 
 class DevelopmentApplication(LocalApplication):
-    """An object for running the application in development mode."""
+    """
+    An object for running the application in development mode.
+
+    This application object will run the Flask application using the
+    built-in Python server on localhost, just like the Flask development
+    mode.
+    """
 
-    default_port = "5000"
-    command = LocalApplication.command + ["--debug"]
+    mode_name = "development"
+    default_port = None  # traditionally 5000
+    _debug = True
 
 
 class ProductionApplication(BaseApplication):
-    """An object for running the application in production mode (via Gunicorn)."""
+    """
+    An object for running the application in production mode (via Gunicorn).
 
-    default_port = "8000"
+    This application object will run the Flask application using a
+    Gunicorn server instead of the built-in Python server.
+    """
+
+    default_port = None  # traditionally 8000
     _default_worker_count = (multiprocessing.cpu_count() * 2) + 1
 
     def __init__(self, host=None, port=None, **options):
         """Initialize the application in production mode."""
-        options["bind"] = self._parse_binding(host, port, options.get("bind"))
-        options.setdefault("workers", self._default_worker_count)
+        if port and not host:
+            raise ValueError("A host must be specified when the port is given.")
+        self._host = host
+        self._port = port or self.default_port
         self.options = options
+        self.options["bind"] = self._determine_binding(options.get("bind"))
+        self.options.setdefault("workers", self._default_worker_count)
         self.application = create_app()
         super().__init__()
 
-    @staticmethod
-    def _parse_binding(host, port, bind_option):
+    def _determine_binding(self, bind_option):
         # Parse any socket binding options
-        if (host or port) and bind_option:
+        if self._host and bind_option:
             raise ValueError(
-                "Neither `host` nor `port` parameters can be specified if the "
-                "`bind` option is given."
+                "The `host` may not be specified directly if the `bind` option is used."
             )
-        bind_values = []
-        if host:
-            bind_values.append(host)
-        if port:
-            bind_values.append(port)
-        return bind if (bind := ":".join(bind_values)) else bind_option
+        if self._host:
+            bind_values = [self._host]
+            if self._port:
+                bind_values.append(self._port)
+            bind_option = ":".join(bind_values)
+        return bind_option
 
     def load_config(self):
         config = {

monopyly/cli/{run.py → launch.py}

@@ -16,26 +16,34 @@ from rich.console import Console
 
 from .apps import DevelopmentApplication, LocalApplication, ProductionApplication
 
-# Set the Flask environment variable
-os.environ["FLASK_APP"] = "monopyly"
 
-
-def main():
-    args = parse_arguments()
-    app_launcher = Launcher(args.mode, host=args.host, port=args.port)
+def main(mode, host=None, port=None, backup=False, browser=False):
+    app_launcher = Launcher(mode, host=host, port=port)
     # Initialize the database and run the app
     app_launcher.initialize_database()
-    if args.backup:
+    if backup:
         app_launcher.backup_database()
     app_launcher.launch()
-    if args.mode in ("development", "local"):
+    if mode in ("development", "local"):
         # Enable browser viewing in development mode
-        if args.browser:
+        if browser:
             app_launcher.open_browser(delay=1)
         # Wait for the exit command to stop
         app_launcher.wait_for_exit()
 
 
+def main_cli():
+    """Run the app as a command line program."""
+    args = parse_arguments()
+    main(
+        args.mode,
+        host=args.host,
+        port=args.port,
+        backup=args.backup,
+        browser=args.browser,
+    )
+
+
 def parse_arguments():
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--host", help="the host address where the app will be run")
@@ -121,4 +129,4 @@ class Launcher:
 
 
 if __name__ == "__main__":
-    main()
+    main_cli()

monopyly/common/forms/_forms.py

@@ -3,6 +3,7 @@ General form constructions.
 """
 
 from abc import ABC, abstractmethod
+from datetime import date
 
 from flask_wtf import FlaskForm
 from wtforms.fields import FieldList, FormField, SelectField, StringField, SubmitField
@@ -165,7 +166,9 @@ class TransactionForm(EntryForm):
             return data
 
     # Fields pertaining to the transaction
-    transaction_date = DateField("Transaction Date", [DataRequired()])
+    transaction_date = DateField(
+        "Transaction Date", validators=[DataRequired()], default=date.today
+    )
     # Subtransactions should be defined as a `FieldList` in a subclass
     subtransactions = None
     submit = SubmitField("Save Transaction")