monopyly 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

monopyly/CHANGELOG.md

@@ -0,0 +1,187 @@
+# 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
+
+<a name="bottom" id="bottom"></a>

monopyly/README.md

@@ -27,12 +27,23 @@ The package requires a recent version of Python (3.9+).
 
 ## 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

@@ -5,6 +5,7 @@ Run a development server for 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.5'
-__version_tuple__ = version_tuple = (1, 4, 5)
+__version__ = version = '1.4.7'
+__version_tuple__ = version_tuple = (1, 4, 7)

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/cli/apps.py

@@ -9,8 +9,17 @@ 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"]
 
@@ -20,7 +29,7 @@ class LocalApplication:
         self._port = 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."
             )
 
     def run(self):
@@ -34,14 +43,26 @@ class LocalApplication:
 
 
 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.
+    """
 
+    mode_name = "development"
     default_port = "5000"
     command = LocalApplication.command + ["--debug"]
 
 
 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).
+
+    This application object will run the Flask application using a
+    Gunicorn server instead of the built-in Python server.
+    """
 
     default_port = "8000"
     _default_worker_count = (multiprocessing.cpu_count() * 2) + 1

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
@@ -34,16 +35,6 @@ class EntryForm(FlaskForm, metaclass=AbstractEntryFormMixinMeta):
         """
         Generate a duplicate prepopulated form.
 
-        Notes
-        -----
-        WTForms requires that a form be instantiated in order to be
-        able to properly introspect fields. Because of this, this method
-        will only return a duplicate form matching the type of the
-        form instance used to call it. Using the form's process method
-        will not properly handle enumeration of field lists, so it
-        can not be used as a replacement for populating an existing
-        form.
-
         Parameters
         ----------
         entry : database.models.Model
@@ -55,6 +46,16 @@ class EntryForm(FlaskForm, metaclass=AbstractEntryFormMixinMeta):
         form : EntryForm
             A duplicate form, prepopulated with the collected database
             information.
+
+        Notes
+        -----
+        WTForms requires that a form be instantiated in order to be
+        able to properly introspect fields. Because of this, this method
+        will only return a duplicate form matching the type of the
+        form instance used to call it. Using the form's process method
+        will not properly handle enumeration of field lists, so it
+        can not be used as a replacement for populating an existing
+        form.
         """
         data = self.gather_entry_data(entry)
         return self.__class__(data=data)
@@ -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")

monopyly/core/actions.py

@@ -10,25 +10,112 @@ def get_timestamp():
     return datetime.now().strftime("%Y%m%d_%H%M%S")
 
 
-def format_readme_as_html_template(readme_text):
-    """Given the README text in Markdown, convert it to a renderable HTML template."""
-    # Convert Markdown to HTML
-    raw_html_readme = markdown.markdown(readme_text, extensions=["fenced_code"])
-    # Replace README relative links with app relevant links
-    html_readme = raw_html_readme.replace('src="monopyly/static', 'src="/static')
-    # Format the HTML as a valid Jinja template
-    html_readme_template = (
-        '{% extends "layout.html" %}'
-        "{% block title %}About{% endblock %}"
-        "{% block content %}"
-        '  <div id="readme" class="about">'
-        f"    {html_readme}"
-        '    <div class="resource-links">'
-        "      <h2>Links</h2>"
-        '      <p><a href="{{ url_for("core.story") }}">Story</a></p>'
-        '      <p><a href="{{ url_for("core.credits") }}">Credits</a></p>'
-        "    </div>"
-        "  </div>"
-        "{% endblock %}"
+class MarkdownConverter:
+
+    replacements = {
+        "src": [
+            ["monopyly/static", "/static"],
+        ],
+        "href": [
+            ["README.md", '{{ url_for("core.about") }}'],
+            ["CHANGELOG.md", '{{ url_for("core.changelog") }}'],
+        ],
+    }
+
+    @classmethod
+    def convert(cls, markdown_path, title, id_="", class_="", extra_content=""):
+        """Given a Markdown file, convert it to a renderable HTML template."""
+        raw_markdown = cls._read_markdown(markdown_path)
+        html_content = cls._convert_markdown_to_html(raw_markdown)
+        return cls._generate_html_template(
+            html_content, title, id_=id_, class_=class_, extra_content=extra_content
+        )
+
+    @staticmethod
+    def _read_markdown(markdown_path):
+        with markdown_path.open(encoding="utf-8") as markdown_file:
+            raw_markdown = markdown_file.read()
+        return raw_markdown
+
+    @classmethod
+    def _convert_markdown_to_html(cls, raw_markdown):
+        raw_html = markdown.markdown(raw_markdown, extensions=["fenced_code"])
+        return cls._replace_links(raw_html)
+
+    @classmethod
+    def _replace_links(cls, raw_html):
+        html = raw_html
+        for tag, pairs in cls.replacements.items():
+            for original, replacement in pairs:
+                html = html.replace(f'{tag}="{original}', f'{tag}="{replacement}')
+        return html
+
+    @staticmethod
+    def _generate_html_template(content, title, id_="", class_="", extra_content=""):
+        # Format the HTML as a valid Jinja template
+        html_template = (
+            '{% extends "layout.html" %}'
+            "{% block title %}"
+            f"  {title}"
+            "{% endblock %}"
+            "{% block content %}"
+            f'  <div id="{id_}" class="{class_}">'
+            f"    {content}"
+            f"    {extra_content}"
+            "{% endblock %}"
+        )
+        return html_template
+
+
+def convert_readme_to_html_template(readme_path):
+    """Given a README file in Markdown, convert it to a renderable HTML template."""
+    return MarkdownConverter.convert(
+        readme_path,
+        title="About",
+        id_="readme",
+        class_="about",
+        extra_content=(
+            '<div class="resource-links">'
+            "  <h2>Links</h2>"
+            '  <p><a href="{{ url_for("core.story") }}">Story</a></p>'
+            '  <p><a href="{{ url_for("core.credits") }}">Credits</a></p>'
+            "</div>"
+        ),
+    )
+
+
+def convert_changelog_to_html_template(changelog_path):
+    """Given a CHANGELOG file in Markdown, convert it to a renderable HTML template."""
+    return MarkdownConverter.convert(
+        changelog_path,
+        title="Changes",
+        id_="changelog",
     )
-    return html_readme_template
+
+
+def determine_summary_balance_svg_viewbox_width(currency_value):
+    """
+    Determine the width of the SVG viewBox attribute displayed in summary boxes.
+
+    Parameters
+    ----------
+    currency_value : str
+        A currency value, displayed in the format output by the
+        `core.filters.make_currency` filter function.
+    """
+    # Set the per-character width contributions
+    digit_width = 55
+    punctuation_width = 25
+    spacing_width = 25
+    # Count the number of commas and non-comma characters in the non-decimal portion
+    nondecimal_value = currency_value.rsplit(".", maxsplit=1)[0]
+    comma_count = nondecimal_value.count(",")
+    digit_count = len(nondecimal_value) - comma_count
+    # Width is the total of the following subcomponents
+    svg_currency_width_subcomponents = [
+        digit_width * digit_count,  # ------------- total width of digits/sign
+        punctuation_width * comma_count,  # ------- total width of commas
+        punctuation_width + (2 * digit_width),  # - width of the decimal section
+        digit_width + spacing_width,  # ----------- width of the dollar sign and spacing
+    ]
+    return max(400, sum(svg_currency_width_subcomponents))

monopyly/core/blueprint.py

@@ -8,4 +8,4 @@ from flask import Blueprint
 bp = Blueprint("core", __name__)
 
 # Import routes after defining blueprint to avoid circular imports
-from . import context_processors, filters, routes
+from . import context_processors, errors, filters, routes

monopyly/core/context_processors.py

@@ -5,6 +5,7 @@ Filters defined for the application.
 from datetime import date
 from importlib import import_module
 
+from .actions import determine_summary_balance_svg_viewbox_width
 from .blueprint import bp
 
 
@@ -19,6 +20,15 @@ def inject_global_template_variables():
     return template_globals
 
 
+@bp.app_context_processor
+def inject_utility_functions():
+    """Inject utility functions globally into the template context."""
+    utility_functions = {
+        "calculate_summary_balance_width": determine_summary_balance_svg_viewbox_width,
+    }
+    return utility_functions
+
+
 def _display_version():
     """Show the version (without commit information)."""
     try:

monopyly/core/errors.py

@@ -0,0 +1,9 @@
+"""
+Tools for handling app errors.
+"""
+
+from flask import render_template
+
+
+def render_error_template(exception):
+    return render_template(f"core/errors/{exception.code}.html", exception=exception)

monopyly/core/filters.py

@@ -2,6 +2,8 @@
 Filters defined for the application.
 """
 
+from math import floor, log10
+
 from .blueprint import bp
 
 
@@ -32,8 +34,8 @@ def make_ordinal(integer):
 
     Notes
     -----
-    This function is an adaptation of the one proposed by Stack Overflow user
-    Florian Brucker (https://stackoverflow.com/a/50992575/8754471).
+    This function is an adaptation of the one proposed by Stack Overflow
+    user Florian Brucker (https://stackoverflow.com/a/50992575/8754471).
 
     Parameters
     ----------

monopyly/core/routes.py

@@ -5,15 +5,18 @@ Routes for core functionality.
 from pathlib import Path
 
 from flask import g, render_template, render_template_string, session
+from werkzeug.exceptions import abort
 
 from ..auth.tools import login_required
 from ..banking.accounts import BankAccountHandler
 from ..banking.banks import BankHandler
 from ..credit.cards import CreditCardHandler
 from ..credit.statements import CreditStatementHandler
-from .actions import format_readme_as_html_template
+from .actions import convert_changelog_to_html_template, convert_readme_to_html_template
 from .blueprint import bp
 
+APP_ROOT_DIR = Path(__file__).parents[1]
+
 
 @bp.route("/")
 def index():
@@ -40,7 +43,7 @@ def index():
         session["show_homepage_block"] = True
         bank_accounts, active_cards = None, None
     return render_template(
-        "index.html", bank_accounts=bank_accounts, cards=active_cards
+        "core/index.html", bank_accounts=bank_accounts, cards=active_cards
     )
 
 
@@ -53,22 +56,27 @@ def hide_homepage_block():
 
 @bp.route("/about")
 def about():
-    readme_path = Path(__file__).parents[1] / "README.md"
-    with readme_path.open(encoding="utf-8") as readme_file:
-        raw_readme_text = readme_file.read()
-    about_page_template = format_readme_as_html_template(raw_readme_text)
+    readme_path = APP_ROOT_DIR / "README.md"
+    about_page_template = convert_readme_to_html_template(readme_path)
     return render_template_string(about_page_template)
 
 
+@bp.route("/changelog")
+def changelog():
+    changelog_path = APP_ROOT_DIR / "CHANGELOG.md"
+    changelog_page_template = convert_changelog_to_html_template(changelog_path)
+    return render_template_string(changelog_page_template)
+
+
 @bp.route("/story")
 @login_required
 def story():
-    return render_template("story.html")
+    return render_template("core/story.html")
 
 
 @bp.route("/credits")
 def credits():
-    return render_template("credits.html")
+    return render_template("core/credits.html")
 
 
 @bp.route("/profile")
@@ -76,4 +84,9 @@ def credits():
 def load_profile():
     banks = BankHandler.get_banks()
     # Return banks as a list to allow multiple reuse
-    return render_template("profile.html", banks=list(banks))
+    return render_template("core/profile.html", banks=list(banks))
+
+
+@bp.route("/change_password")
+def change_password():
+    abort(418)