finforge 1.0.0__py3-none-any.whl

finforge/__init__.py

@@ -0,0 +1,5 @@
+"""Public package exports for FinForge."""
+
+from finforge.dataset import DatasetGenerator
+
+__all__ = ["DatasetGenerator"]

finforge/behavior/__init__.py

@@ -0,0 +1 @@
+"""Behavioral simulation components for FinForge."""

finforge/behavior/adaptive_spending.py

@@ -0,0 +1,129 @@
+"""Adaptive spending adjustments based on balance, budget, and lifecycle."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from finforge.behavior.budgeting import BudgetingEngine, UserBudgetState
+from finforge.core.models import User
+from finforge.personas.base import SpendingProfile
+
+
+@dataclass(frozen=True)
+class AdaptiveSpendingSignal:
+    """Per-day spending signal derived from balance and memory."""
+
+    state: str
+    frequency_multiplier: float
+    amount_multiplier: float
+    category_multipliers: dict[str, float]
+    amount_multipliers: dict[str, float]
+    overspend_pressure: float
+    lifecycle_phase: str
+    max_discretionary_transactions: int | None
+
+
+class AdaptiveSpendingEngine:
+    """Combines balance, month phase, and recent spend memory."""
+
+    def __init__(self, budgeting_engine: BudgetingEngine) -> None:
+        self.budgeting_engine = budgeting_engine
+
+    def assess(
+        self,
+        user: User,
+        state: UserBudgetState,
+        day_of_month: int,
+        days_in_month: int,
+        spending_profile: SpendingProfile,
+    ) -> AdaptiveSpendingSignal:
+        """Compute day-level adaptive spending controls."""
+        phase = self._phase(day_of_month, days_in_month)
+        overspend = self.budgeting_engine.overspend_pressure(state)
+        low_threshold, high_threshold = self._thresholds(user)
+        category_multipliers = {category: 1.0 for category in user.category_affinities}
+        amount_multipliers = {category: 1.0 for category in user.category_affinities}
+
+        for category, affinity in user.category_affinities.items():
+            category_multipliers[category] *= affinity
+
+        if phase == "early":
+            category_multipliers["shopping"] = category_multipliers.get("shopping", 1.0) * (1.05 + user.impulse_buying_score * 0.18)
+            category_multipliers["entertainment"] = category_multipliers.get("entertainment", 1.0) * (1.03 + user.entertainment_preference * 0.15)
+        elif phase == "late":
+            for category, multiplier in spending_profile.month_end_category_multipliers.items():
+                category_multipliers[category] = category_multipliers.get(category, 1.0) * multiplier
+
+        if state.balance <= low_threshold:
+            low_balance_multipliers = {
+                "entertainment": 0.10,
+                "shopping": 0.15,
+                "food": 0.40,
+                "coffee": 0.50,
+                "travel": 0.80,
+                "groceries": 1.20,
+            }
+            low_balance_amount_multipliers = {
+                "entertainment": 0.50,
+                "shopping": 0.50,
+                "food": 0.65,
+                "coffee": 0.75,
+                "travel": 0.90,
+                "groceries": 1.00,
+            }
+            for category, multiplier in low_balance_multipliers.items():
+                category_multipliers[category] = category_multipliers.get(category, 1.0) * multiplier
+            for category, multiplier in low_balance_amount_multipliers.items():
+                amount_multipliers[category] = amount_multipliers.get(category, 1.0) * multiplier
+            signal_state = "low"
+            frequency_multiplier = 0.26 if user.persona.value == "student" else 0.34
+            amount_multiplier = 0.46
+            max_discretionary_transactions = 1 if user.persona.value == "student" else 2
+        elif state.balance >= high_threshold:
+            for category, multiplier in spending_profile.high_balance_category_multipliers.items():
+                category_multipliers[category] = category_multipliers.get(category, 1.0) * multiplier
+            signal_state = "high"
+            frequency_multiplier = 1.10
+            amount_multiplier = 1.08
+            max_discretionary_transactions = None
+        else:
+            signal_state = "normal"
+            frequency_multiplier = 1.0
+            amount_multiplier = 1.0
+            max_discretionary_transactions = None
+
+        if overspend > 1.0:
+            pressure_discount = min((overspend - 1.0) * 0.35, 0.4)
+            frequency_multiplier *= 1.0 - pressure_discount
+            amount_multiplier *= 1.0 - pressure_discount * 0.8
+            category_multipliers["shopping"] = category_multipliers.get("shopping", 1.0) * 0.45
+            category_multipliers["entertainment"] = category_multipliers.get("entertainment", 1.0) * 0.55
+            category_multipliers["food"] = category_multipliers.get("food", 1.0) * 0.78
+            amount_multipliers["shopping"] = amount_multipliers.get("shopping", 1.0) * 0.7
+            amount_multipliers["entertainment"] = amount_multipliers.get("entertainment", 1.0) * 0.75
+            amount_multipliers["food"] = amount_multipliers.get("food", 1.0) * 0.85
+
+        return AdaptiveSpendingSignal(
+            state=signal_state,
+            frequency_multiplier=round(frequency_multiplier, 3),
+            amount_multiplier=round(amount_multiplier, 3),
+            category_multipliers={key: round(value, 3) for key, value in category_multipliers.items()},
+            amount_multipliers={key: round(value, 3) for key, value in amount_multipliers.items()},
+            overspend_pressure=round(overspend, 3),
+            lifecycle_phase=phase,
+            max_discretionary_transactions=max_discretionary_transactions,
+        )
+
+    def _phase(self, day_of_month: int, days_in_month: int) -> str:
+        """Map a day in month into a lifecycle phase."""
+        if day_of_month <= 7:
+            return "early"
+        if day_of_month >= max(days_in_month - 5, 25):
+            return "late"
+        return "mid"
+
+    def _thresholds(self, user: User) -> tuple[float, float]:
+        """Return persona-level low and high balance thresholds."""
+        if user.persona.value == "student":
+            return 500.0, 5000.0
+        return 5000.0, 50000.0

finforge/behavior/balance_awareness.py

@@ -0,0 +1,94 @@
+"""Balance-aware spending adjustments."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from finforge.personas.base import SpendingProfile
+
+
+@dataclass(frozen=True)
+class BalanceAdjustment:
+    """Spending modifiers derived from current financial headroom."""
+
+    state: str
+    frequency_multiplier: float
+    amount_multiplier: float
+    category_multipliers: dict[str, float]
+
+
+class BalanceAwarenessEngine:
+    """Adjusts spending based on current liquidity and month timing."""
+
+    def assess(
+        self,
+        current_balance: float,
+        monthly_income: float,
+        day_of_month: int,
+        days_in_month: int,
+        spending_profile: SpendingProfile,
+        savings_preference: float,
+    ) -> BalanceAdjustment:
+        """Return spending modifiers for the user's current financial state."""
+        low_threshold = max(monthly_income * 0.18 * savings_preference, 120.0)
+        high_threshold = max(monthly_income * 0.85, 900.0)
+        month_end = day_of_month >= max(days_in_month - 4, 24)
+
+        if current_balance <= low_threshold:
+            category_multipliers = dict(spending_profile.low_balance_category_multipliers)
+            if month_end:
+                category_multipliers = self._merge_category_multipliers(
+                    category_multipliers,
+                    spending_profile.month_end_category_multipliers,
+                )
+            return BalanceAdjustment(
+                state="low",
+                frequency_multiplier=0.50,
+                amount_multiplier=0.72,
+                category_multipliers=category_multipliers,
+            )
+
+        if current_balance >= high_threshold:
+            category_multipliers = dict(spending_profile.high_balance_category_multipliers)
+            if month_end:
+                category_multipliers = self._merge_category_multipliers(
+                    category_multipliers,
+                    spending_profile.month_end_category_multipliers,
+                )
+            return BalanceAdjustment(
+                state="high",
+                frequency_multiplier=1.15,
+                amount_multiplier=1.10,
+                category_multipliers=category_multipliers,
+            )
+
+        category_multipliers = {category: 1.0 for category in spending_profile.category_weights_weekday}
+        if month_end:
+            category_multipliers = self._merge_category_multipliers(
+                category_multipliers,
+                spending_profile.month_end_category_multipliers,
+            )
+            return BalanceAdjustment(
+                state="normal",
+                frequency_multiplier=0.88,
+                amount_multiplier=0.92,
+                category_multipliers=category_multipliers,
+            )
+
+        return BalanceAdjustment(
+            state="normal",
+            frequency_multiplier=1.0,
+            amount_multiplier=1.0,
+            category_multipliers=category_multipliers,
+        )
+
+    def _merge_category_multipliers(
+        self,
+        base: dict[str, float],
+        overlay: dict[str, float],
+    ) -> dict[str, float]:
+        """Multiply an existing category map by another one."""
+        merged = dict(base)
+        for category, multiplier in overlay.items():
+            merged[category] = round(merged.get(category, 1.0) * multiplier, 4)
+        return merged

finforge/behavior/budgeting.py

@@ -0,0 +1,78 @@
+"""Budget memory and discretionary spending state."""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+
+from finforge.core.models import User
+
+
+@dataclass
+class UserBudgetState:
+    """Mutable simulation state for a user's cashflow and spending memory."""
+
+    balance: float
+    discretionary_budget: float
+    discretionary_spent: float = 0.0
+    essentials_spent: float = 0.0
+    income_received: float = 0.0
+    pressure_score: float = 0.0
+    recent_discretionary_spend: deque[float] = field(default_factory=lambda: deque(maxlen=10))
+    recent_daily_spend: deque[float] = field(default_factory=lambda: deque(maxlen=14))
+
+
+class BudgetingEngine:
+    """Tracks ongoing spending pressure and budget fatigue."""
+
+    DISCRETIONARY_CATEGORIES = {"food", "shopping", "entertainment"}
+
+    def start_user(self, user: User) -> UserBudgetState:
+        """Create a budget state for a new user."""
+        return UserBudgetState(
+            balance=user.initial_balance,
+            discretionary_budget=self._monthly_discretionary_budget(user),
+        )
+
+    def start_month(self, state: UserBudgetState, user: User) -> None:
+        """Reset month-scoped budget counters while keeping recent memory."""
+        state.discretionary_budget = self._monthly_discretionary_budget(user)
+        state.discretionary_spent = 0.0
+        state.essentials_spent = 0.0
+        state.income_received = 0.0
+        state.pressure_score = 0.0
+
+    def record_transaction(self, state: UserBudgetState, amount: float, category: str) -> None:
+        """Update budgeting memory after a transaction is applied."""
+        if amount > 0:
+            state.income_received += amount
+            if category == "income" and state.discretionary_budget < amount * 0.35:
+                state.discretionary_budget += amount * 0.08
+            return
+
+        spend = abs(amount)
+        if category in self.DISCRETIONARY_CATEGORIES:
+            state.discretionary_spent += spend
+            state.recent_discretionary_spend.append(spend)
+            state.recent_daily_spend.append(spend)
+        elif category != "income":
+            state.essentials_spent += spend
+            state.recent_daily_spend.append(spend * 0.35)
+
+        budget_ratio = state.discretionary_spent / max(state.discretionary_budget, 1.0)
+        recent_pressure = sum(state.recent_discretionary_spend) / max(state.discretionary_budget * 0.35, 1.0)
+        state.pressure_score = round(max(budget_ratio, recent_pressure), 3)
+
+    def overspend_pressure(self, state: UserBudgetState) -> float:
+        """Return a smooth overspend indicator."""
+        return min(max(state.pressure_score, 0.0), 2.2)
+
+    def _monthly_discretionary_budget(self, user: User) -> float:
+        """Derive a discretionary budget from user traits."""
+        base_ratio = 0.34 if user.persona.value == "student" else 0.27
+        ratio = base_ratio * user.spending_intensity / max(user.savings_tendency, 0.5)
+        ratio *= 0.75 + user.lifestyle_score * 0.45
+        budget = max(user.monthly_income * ratio, 80.0)
+        reserved_subscriptions = sum(user.recurring_subscription_amounts.values())
+        budget -= reserved_subscriptions * 0.55
+        return round(max(budget, 45.0), 2)

finforge/behavior/clustering.py

@@ -0,0 +1,102 @@
+"""Temporal clustering for human-like transaction bursts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+
+from finforge.utils.dates import combine_timestamp
+from finforge.utils.randomness import RandomContext
+
+
+@dataclass(frozen=True)
+class SessionTemplate:
+    """A reusable daily spending cluster pattern."""
+
+    name: str
+    category_sequence: tuple[str, ...]
+    hour_range: tuple[int, int]
+    minute_offsets: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class ClusteredEvent:
+    """A planned transaction event inside a behavioral cluster."""
+
+    timestamp: datetime
+    category: str
+
+
+class ClusteringEngine:
+    """Generates grouped transaction bursts instead of isolated events."""
+
+    def __init__(self, random_context: RandomContext) -> None:
+        self.random_context = random_context
+        self.templates = {
+            "commute_coffee": SessionTemplate(
+                name="commute_coffee",
+                category_sequence=("travel", "coffee"),
+                hour_range=(7, 9),
+                minute_offsets=(0, 35),
+            ),
+            "lunch_run": SessionTemplate(
+                name="lunch_run",
+                category_sequence=("food",),
+                hour_range=(12, 14),
+                minute_offsets=(0,),
+            ),
+            "grocery_stop": SessionTemplate(
+                name="grocery_stop",
+                category_sequence=("groceries",),
+                hour_range=(18, 21),
+                minute_offsets=(0,),
+            ),
+            "weekend_hangout": SessionTemplate(
+                name="weekend_hangout",
+                category_sequence=("food", "entertainment"),
+                hour_range=(13, 20),
+                minute_offsets=(0, 110),
+            ),
+            "shopping_trip": SessionTemplate(
+                name="shopping_trip",
+                category_sequence=("shopping", "food"),
+                hour_range=(12, 18),
+                minute_offsets=(0, 95),
+            ),
+            "cinema_night": SessionTemplate(
+                name="cinema_night",
+                category_sequence=("entertainment", "food"),
+                hour_range=(18, 21),
+                minute_offsets=(0, 140),
+            ),
+            "food_run": SessionTemplate(
+                name="food_run",
+                category_sequence=("food",),
+                hour_range=(18, 22),
+                minute_offsets=(0,),
+            ),
+            "campus_commute": SessionTemplate(
+                name="campus_commute",
+                category_sequence=("coffee", "food", "travel"),
+                hour_range=(8, 11),
+                minute_offsets=(0, 190, 430),
+            ),
+            "late_streaming": SessionTemplate(
+                name="late_streaming",
+                category_sequence=("entertainment",),
+                hour_range=(21, 23),
+                minute_offsets=(0,),
+            ),
+        }
+
+    def build_session(self, target_date: date, template_name: str) -> list[ClusteredEvent]:
+        """Generate clustered events for a daily session template."""
+        template = self.templates[template_name]
+        base_hour = self.random_context.rng.randint(template.hour_range[0], template.hour_range[1])
+        base_minute = self.random_context.rng.randint(0, 45)
+        base_timestamp = combine_timestamp(target_date, base_hour, base_minute)
+        events: list[ClusteredEvent] = []
+        for category, offset in zip(template.category_sequence, template.minute_offsets):
+            timestamp = base_timestamp + timedelta(minutes=offset)
+            events.append(ClusteredEvent(timestamp=timestamp, category=category))
+        return events

finforge/behavior/identity.py

@@ -0,0 +1,168 @@
+"""Persistent user identity generation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from finforge.core.models import User
+from finforge.utils.randomness import RandomContext
+
+
+@dataclass(frozen=True)
+class IdentityProfile:
+    """Stable long-term behavioral traits for a user."""
+
+    spending_style: str
+    savings_tendency: float
+    merchant_loyalty: float
+    lifestyle_score: float
+    impulse_buying_score: float
+    entertainment_preference: float
+    preferred_categories: list[str]
+    category_affinities: dict[str, float]
+    commute_pattern: str
+    night_activity_score: float
+    spending_intensity: float
+    savings_preference: float
+
+
+class IdentityEngine:
+    """Creates persistent financial personalities."""
+
+    _STYLE_LIBRARY = {
+        "salaried": (
+            {
+                "name": "budget_conscious",
+                "weight": 0.35,
+                "savings_tendency": (1.15, 1.45),
+                "merchant_loyalty": (0.65, 0.9),
+                "lifestyle_score": (0.25, 0.45),
+                "impulse_buying_score": (0.15, 0.35),
+                "entertainment_preference": (0.2, 0.4),
+                "preferred_categories": ("groceries", "travel", "coffee"),
+                "commute_patterns": ("public_transit", "mixed"),
+                "night_activity_score": (0.15, 0.35),
+                "spending_intensity": (0.72, 0.95),
+            },
+            {
+                "name": "lifestyle_spender",
+                "weight": 0.40,
+                "savings_tendency": (0.7, 0.95),
+                "merchant_loyalty": (0.55, 0.8),
+                "lifestyle_score": (0.65, 0.95),
+                "impulse_buying_score": (0.45, 0.7),
+                "entertainment_preference": (0.65, 0.9),
+                "preferred_categories": ("food", "entertainment", "shopping"),
+                "commute_patterns": ("ride_hailing", "mixed"),
+                "night_activity_score": (0.45, 0.75),
+                "spending_intensity": (1.05, 1.3),
+            },
+            {
+                "name": "minimalist",
+                "weight": 0.25,
+                "savings_tendency": (1.2, 1.55),
+                "merchant_loyalty": (0.75, 0.95),
+                "lifestyle_score": (0.15, 0.35),
+                "impulse_buying_score": (0.1, 0.25),
+                "entertainment_preference": (0.12, 0.25),
+                "preferred_categories": ("groceries", "coffee", "travel"),
+                "commute_patterns": ("public_transit",),
+                "night_activity_score": (0.08, 0.25),
+                "spending_intensity": (0.55, 0.82),
+            },
+        ),
+        "student": (
+            {
+                "name": "impulsive_student",
+                "weight": 0.45,
+                "savings_tendency": (0.45, 0.75),
+                "merchant_loyalty": (0.45, 0.7),
+                "lifestyle_score": (0.55, 0.85),
+                "impulse_buying_score": (0.7, 0.95),
+                "entertainment_preference": (0.7, 0.95),
+                "preferred_categories": ("entertainment", "food", "coffee"),
+                "commute_patterns": ("ride_hailing", "mixed"),
+                "night_activity_score": (0.65, 0.95),
+                "spending_intensity": (1.1, 1.4),
+            },
+            {
+                "name": "budget_conscious",
+                "weight": 0.35,
+                "savings_tendency": (0.95, 1.2),
+                "merchant_loyalty": (0.6, 0.85),
+                "lifestyle_score": (0.25, 0.45),
+                "impulse_buying_score": (0.2, 0.4),
+                "entertainment_preference": (0.3, 0.55),
+                "preferred_categories": ("food", "groceries", "travel"),
+                "commute_patterns": ("public_transit", "mixed"),
+                "night_activity_score": (0.25, 0.5),
+                "spending_intensity": (0.75, 0.98),
+            },
+            {
+                "name": "minimalist",
+                "weight": 0.20,
+                "savings_tendency": (1.05, 1.35),
+                "merchant_loyalty": (0.72, 0.92),
+                "lifestyle_score": (0.15, 0.3),
+                "impulse_buying_score": (0.12, 0.25),
+                "entertainment_preference": (0.15, 0.3),
+                "preferred_categories": ("groceries", "coffee", "food"),
+                "commute_patterns": ("public_transit",),
+                "night_activity_score": (0.05, 0.2),
+                "spending_intensity": (0.55, 0.8),
+            },
+        ),
+    }
+
+    _CATEGORY_BIASES = {
+        "budget_conscious": {"groceries": 1.2, "coffee": 0.9, "travel": 1.0, "food": 0.9, "shopping": 0.55, "entertainment": 0.6},
+        "lifestyle_spender": {"groceries": 0.85, "coffee": 1.0, "travel": 1.0, "food": 1.25, "shopping": 1.15, "entertainment": 1.3},
+        "minimalist": {"groceries": 1.15, "coffee": 0.9, "travel": 0.95, "food": 0.8, "shopping": 0.45, "entertainment": 0.45},
+        "impulsive_student": {"groceries": 0.7, "coffee": 1.05, "travel": 0.85, "food": 1.15, "shopping": 0.95, "entertainment": 1.4},
+    }
+
+    def __init__(self, random_context: RandomContext) -> None:
+        self.random_context = random_context
+
+    def build_for_user(self, user: User) -> IdentityProfile:
+        """Create a persistent identity profile for a user."""
+        templates = self._STYLE_LIBRARY[user.persona.value]
+        selected = self.random_context.rng.choices(
+            population=list(templates),
+            weights=[template["weight"] for template in templates],
+            k=1,
+        )[0]
+        style_name = str(selected["name"])
+        preferred_categories = list(selected["preferred_categories"])
+        self.random_context.rng.shuffle(preferred_categories)
+        preferred_categories = preferred_categories[:2]
+        commute_pattern = self.random_context.rng.choice(list(selected["commute_patterns"]))
+
+        category_affinities = self._build_category_affinities(style_name)
+        return IdentityProfile(
+            spending_style=style_name,
+            savings_tendency=round(self._sample_range(selected["savings_tendency"]), 2),
+            merchant_loyalty=round(self._sample_range(selected["merchant_loyalty"]), 2),
+            lifestyle_score=round(self._sample_range(selected["lifestyle_score"]), 2),
+            impulse_buying_score=round(self._sample_range(selected["impulse_buying_score"]), 2),
+            entertainment_preference=round(self._sample_range(selected["entertainment_preference"]), 2),
+            preferred_categories=preferred_categories,
+            category_affinities=category_affinities,
+            commute_pattern=commute_pattern,
+            night_activity_score=round(self._sample_range(selected["night_activity_score"]), 2),
+            spending_intensity=round(self._sample_range(selected["spending_intensity"]), 2),
+            savings_preference=round(self._sample_range(selected["savings_tendency"]), 2),
+        )
+
+    def _build_category_affinities(self, style_name: str) -> dict[str, float]:
+        """Build stable user category affinities."""
+        base_bias = self._CATEGORY_BIASES[style_name]
+        affinities = {}
+        for category, bias in base_bias.items():
+            noise = self.random_context.rng.uniform(0.92, 1.08)
+            affinities[category] = round(bias * noise, 3)
+        return affinities
+
+    def _sample_range(self, value_range: tuple[float, float]) -> float:
+        """Sample a random value from a range."""
+        return self.random_context.rng.uniform(value_range[0], value_range[1])

finforge/behavior/lifecycle.py

@@ -0,0 +1,64 @@
+"""Monthly lifecycle and cashflow helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+
+from finforge.behavior.budgeting import UserBudgetState
+from finforge.core.models import User
+from finforge.utils.randomness import RandomContext
+
+
+@dataclass(frozen=True)
+class LifecycleContext:
+    """Lightweight lifecycle classification for a given day."""
+
+    phase: str
+    is_weekend: bool
+    financial_stress: bool
+
+
+class FinancialLifecycleEngine:
+    """Encodes persona-specific monthly financial rhythm."""
+
+    def __init__(self, random_context: RandomContext) -> None:
+        self.random_context = random_context
+
+    def context_for_day(self, user: User, target_date: date, state: UserBudgetState, days_in_month: int) -> LifecycleContext:
+        """Return lifecycle context for a user on a day."""
+        if target_date.day <= 7:
+            phase = "early"
+        elif target_date.day >= max(days_in_month - 5, 25):
+            phase = "late"
+        else:
+            phase = "mid"
+        financial_stress = phase == "late" or state.balance < max(user.monthly_income * 0.14, 120.0)
+        return LifecycleContext(
+            phase=phase,
+            is_weekend=target_date.weekday() >= 5,
+            financial_stress=financial_stress,
+        )
+
+    def irregular_income_for_day(self, user: User, target_date: date, state: UserBudgetState) -> list[dict[str, object]]:
+        """Create persona-specific irregular inflows."""
+        if user.persona.value != "student":
+            return []
+        inflows: list[dict[str, object]] = []
+        chance = 0.05
+        if state.balance < 120:
+            chance = 0.12
+        if target_date.day in {17, 24}:
+            chance += 0.03
+        if self.random_context.rng.random() < chance:
+            merchant = "Family Transfer" if state.balance < 90 else "Freelance Client"
+            amount = self.random_context.rng.uniform(35.0, 140.0) if merchant == "Freelance Client" else self.random_context.rng.uniform(60.0, 180.0)
+            inflows.append(
+                {
+                    "merchant": merchant,
+                    "category": "income",
+                    "amount": round(amount, 2),
+                    "time_bucket": "afternoon",
+                }
+            )
+        return inflows