feat: added initial implementation of ExpenseIncomeStats for calculating expense and income statistics

Author: ca20110820

projects/Expense-Tracker/README.md

@@ -1,9 +1,9 @@
 # Expense Tracker App
 
 ## Tasks
-- [ ] Expense Categorization: This feature allows users to classify their expenses into categories like food, transportation, and entertainment, and provides a summary based on these categories.
-- [ ] Date Range Filtering: This feature enables users to filter and view their expenses within a specific date range.
+- [X] Expense Categorization: This feature allows users to classify their expenses into categories like food, transportation, and entertainment, and provides a summary based on these categories.
+- [X] Date Range Filtering: This feature enables users to filter and view their expenses within a specific date range.
 - [ ] Expense Analysis: This feature offers statistical insights such as the average expense, highest expense, lowest expense, etc.
-- [ ] Data Saving and Loading: This feature lets users save their expense data to a file (like CSV or JSON) and load it back when needed.
+- [X] Data Saving and Loading: This feature lets users save their expense data to a file (like CSV or JSON) and load it back when needed.
 - [ ] Data Export to PDF/Excel: This feature enables users to export their expense data to common formats like PDF or Excel for easy sharing or printing.
 - [ ] Currency Converter: For users dealing with multiple currencies, this feature provides an option to convert expenses to a preferred currency.

projects/Expense-Tracker/expense_income_stats.py

@@ -0,0 +1,105 @@
+from abc import ABC, abstractmethod
+from item import ItemsDB
+import statistics
+
+
+class ExpenseIncomeStats:
+    def __init__(self, db_path: str, start: str = None, end: str = None):
+        self._items_db = ItemsDB(db_path)
+        self.start = start
+        self.end = end
+
+        if start is None and end is None:
+            # Get all Items
+            self._items = self._items_db.get_all_items()
+            pass
+        elif start is None and end is not None:
+            # Start from the Oldest Item(s) to the given end date string
+            oldest = min(item.date for item in self._items_db.get_all_items())
+            self._items = self._items_db.get_items_by_date_range(oldest.strftime("%Y-%m-%d"), end)
+        elif start is not None and end is None:
+            # Start from the given start date string to the latest date
+            latest = max(item.date for item in self._items_db.get_all_items())
+            self._items = self._items_db.get_items_by_date_range(start, latest.strftime("%Y-%m-%d"))
+        else:
+            # Get item from given date range
+            self._items = self._items_db.get_items_by_date_range(start, end)
+
+    @staticmethod
+    def _get_stats(items) -> dict:
+        expense_items = [item.amount for item in items if item.amount < 0]
+        if len(expense_items) > 0:
+            expense_stats = {
+                "average_expense": statistics.mean(expense_items),
+                "min_expense": max(expense_items),  # Warn: Negative Sign
+                "max_expense": min(expense_items),
+            }
+        else:
+            expense_stats = {}
+
+        income_items = [item.amount for item in items if item.amount > 0]
+        if len(income_items) > 0:
+            income_stats = {
+                "average_income": statistics.mean(income_items),
+                "min_income": min(income_items),
+                "max_income": max(income_items),
+            }
+        else:
+            income_stats = {}
+
+        return expense_stats | income_stats
+
+    def get_stats(self):
+        return self._get_stats(self._items)
+
+    def get_stats_by_category(self) -> dict:
+        # The 'root' of category (i.e. it aggregates the subcategories). We do not care about the subcategories.
+        # Set of Root Categories
+        # item.get_category_str() for an item without category would return 'Uncategorized'
+        category_names = {item.category.name if item.category is not None else item.get_category_str() for item in
+                          self._items}
+
+        out_dict = {}
+        for category_name in category_names:
+            items = [item for item in self._items if item.category.name == category_name]
+            out_dict[category_name] = self._get_stats(items)
+
+        return out_dict
+
+    def get_stats_by_category_with_subcategories(self) -> dict:
+        category_names = self._items_db.get_category_names()
+        stats_dict = {}
+        for category_name in category_names:
+            # Case: With Category and Without Subcategory
+            stats_dict[f'{category_name}-NoSubcategory'] = self._get_stats(
+                self._items_db.get_items_without_subcategory(category_name))
+            # Case: With Category and With Subcategory
+            for subcategory in self._items_db.get_subcategory_name(category_name):
+                stats_dict[f'{category_name}-{subcategory}'] = \
+                    self._get_stats(self._items_db.get_items_by_category_and_subcategory(category_name, subcategory))
+
+        return stats_dict
+
+    @staticmethod
+    def currency_converter(base_currency: str, quote_currency: str) -> float:
+        # TODO: Implement currency_converter() method.
+        pass
+
+
+class Report(ABC):
+    @abstractmethod
+    def generate_report(self, *args, **kwargs):
+        pass
+
+
+class ExcelReport(Report):
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    def generate_report(self):
+        pass
+
+
+class PdfReport(Report):
+    def generate_report(self):
+        pass

projects/Expense-Tracker/item.py

@@ -1,4 +1,4 @@
-from typing import Optional, List
+from typing import Optional, List, Set
 from dataclasses import dataclass, asdict, is_dataclass
 from datetime import datetime
 from copy import deepcopy
@@ -21,6 +21,18 @@ class Category:
     name: str
     subcategory: Optional[str] = None
 
+    def __str__(self):
+        if self.subcategory is None:
+            return f'{self.name}-NoSubcategory'
+        else:
+            return f'{self.name}-{self.subcategory}'
+
+    def __eq__(self, other):
+        return self.name == other.name and self.subcategory == other.subcategory
+
+    def is_same_category_name(self, other):
+        return self.name == other.name
+
 
 @dataclass
 class Item:
@@ -34,6 +46,9 @@ class Item:
     def __str__(self):
         return self.to_json_str(indent=4)
 
+    def get_category_str(self) -> str:
+        return "Uncategorized" if self.category is None else str(self.category)
+
     @classmethod
     def create(cls, name: str, amount: float, description: str, date_str: str, category: Optional[Category] = None):
         item_id = str(uuid.uuid4())  # Generate a unique ID
@@ -120,7 +135,38 @@ def delete_all_items(self):
     def get_all_items(self) -> List[Item]:
         return [Item.from_json_str(json.dumps(doc)) for doc in self._db.all()]
 
-    def get_items_by_date_range(self, start: str, end: str):
+    def get_items_by_date_range(self, start: str, end: str) -> List[Item]:
         start_date = datetime.strptime(start, "%Y-%m-%d")
         end_date = datetime.strptime(end, "%Y-%m-%d")
         return [item for item in self.get_all_items() if start_date <= item.date <= end_date]
+
+    def get_items_by_category(self, category_name: str) -> List[Item]:
+        return [item for item in self.get_all_items() if item.category.name == category_name]
+
+    def get_items_by_category_and_subcategory(self, category_name: str, subcategory_name: str) -> List[Item]:
+        return [item for item in self.get_all_items() if
+                item.category.name == category_name and item.category.subcategory == subcategory_name]
+
+    def get_items_uncategorized(self) -> List[Item]:
+        return [item for item in self.get_all_items() if item.category is None]
+
+    def get_items_without_subcategory(self, category_name: str) -> List[Item]:
+        # This excludes uncategorized items (i.e. item.category is None)
+        return [item for item in self.get_all_items() if
+                item.category is not None and item.category.name == category_name and item.category.subcategory is None]
+
+    def get_items_with_subcategory(self, category_name: str) -> List[Item]:
+        # This excludes uncategorized items (i.e. item.category is None)
+        return [item for item in self.get_all_items() if
+                item.category is not None and item.category.name == category_name and item.category.subcategory is not
+                None]
+
+    def get_category_names(self) -> Set[str]:
+        # This excludes the Items with No Category (i.e. item.category is None)
+        return {item.category.name for item in self.get_all_items() if item.category is not None}
+
+    def get_subcategory_name(self, category_name: str) -> Set[str]:
+        # This excludes items without subcategories
+        return {item.category.subcategory for item in self.get_all_items() if
+                item.category is not None and item.category.name == category_name and item.category.subcategory is not
+                None}