Revenue Recognition Model Expert

class PerformanceObligation:
    def __init__(self, description, standalone_selling_price, distinct=True):
        self.description = description
        self.ssp = standalone_selling_price
        self.distinct = distinct
        self.satisfaction_method = None  # 'point_in_time' or 'over_time'
        self.allocated_price = 0

    def determine_satisfaction_method(self):
        # Criteria for over-time recognition
        criteria = {
            'customer_simultaneously_receives': False,
            'creates_or_enhances_asset': False,
            'no_alternative_use_with_payment': False
        }

        if any(criteria.values()):
            self.satisfaction_method = 'over_time'
        else:
            self.satisfaction_method = 'point_in_time'

        return self.satisfaction_method

import numpy as np
from scipy import stats

class VariableConsideration:
    def __init__(self, base_price, variable_components):
        self.base_price = base_price
        self.variable_components = variable_components

    def calculate_expected_value(self):
        """Expected value method for variable consideration"""
        expected_variable = 0

        for component in self.variable_components:
            if component['type'] == 'bonus':
                expected_variable += component['amount'] * component['probability']
            elif component['type'] == 'penalty':
                expected_variable -= component['amount'] * component['probability']

        return self.base_price + expected_variable

    def apply_constraint(self, constraint_threshold=0.5):
        """Apply constraint to prevent revenue reversal"""
        unconstrained_amount = self.calculate_expected_value()

        # Most likely amount method for binary outcomes
        confidence_level = self._calculate_confidence()

        if confidence_level < constraint_threshold:
            # Exclude variable consideration due to constraint
            return self.base_price
        else:
            return unconstrained_amount

class ContractModification:
    def __init__(self, original_contract, modification_details):
        self.original_contract = original_contract
        self.modification = modification_details

    def analyze_modification_type(self):
        """Determine if modification creates new contract or modifies existing"""

        # Check if goods/services are distinct
        distinct_goods = self._are_goods_distinct()

        # Check if price reflects standalone selling price
        ssp_pricing = self._reflects_ssp_pricing()

        if distinct_goods and ssp_pricing:
            return 'separate_contract'
        elif distinct_goods and not ssp_pricing:
            return 'terminate_and_create'
        else:
            return 'cumulative_catchup'

    def process_modification(self):
        modification_type = self.analyze_modification_type()

        if modification_type == 'separate_contract':
            return self._create_separate_contract()
        elif modification_type == 'terminate_and_create':
            return self._terminate_and_create_new()
        else:
            return self._apply_cumulative_catchup()

class SoftwareRevenue:
    def __init__(self, contract_value, license_portion, support_portion, 
                 implementation_portion):
        self.contract_value = contract_value
        self.components = {
            'license': license_portion,
            'support': support_portion, 
            'implementation': implementation_portion
        }

    def allocate_transaction_price(self):
        """Allocate based on standalone selling prices"""
        total_ssp = sum(self.components.values())
        allocation = {}

        for component, ssp in self.components.items():
            allocation[component] = (ssp / total_ssp) * self.contract_value

        return allocation

    def recognize_revenue_schedule(self, start_date, license_delivery_date, 
                                 support_period_months):
        allocation = self.allocate_transaction_price()

        schedule = {
            'license': {
                'amount': allocation['license'],
                'recognition_date': license_delivery_date,
                'method': 'point_in_time'
            },
            'support': {
                'amount': allocation['support'],
                'monthly_amount': allocation['support'] / support_period_months,
                'method': 'over_time'
            },
            'implementation': {
                'amount': allocation['implementation'], 
                'method': 'percentage_of_completion'
            }
        }

        return schedule

-- Revenue Recognition Control Queries

-- 1. Validate all contracts have proper performance obligation mapping
SELECT contract_id, COUNT(*) as po_count
FROM performance_obligations 
WHERE contract_id IN (SELECT contract_id FROM active_contracts)
GROUP BY contract_id
HAVING COUNT(*) = 0;

-- 2. Check for revenue recognized without satisfied performance obligations
SELECT r.contract_id, r.amount, po.satisfaction_status
FROM revenue_recognized r
JOIN performance_obligations po ON r.po_id = po.po_id
WHERE po.satisfaction_status != 'satisfied'
AND r.recognition_date <= CURRENT_DATE;

-- 3. Validate transaction price allocation equals contract value
SELECT 
    contract_id,
    contract_value,
    SUM(allocated_amount) as total_allocated,
    ABS(contract_value - SUM(allocated_amount)) as variance
FROM contract_allocations
GROUP BY contract_id, contract_value
HAVING ABS(contract_value - SUM(allocated_amount)) > 0.01;

def calculate_revenue_kpis(revenue_data):
    kpis = {
        'contract_liability_ratio': revenue_data['contract_liabilities'] / revenue_data['total_bookings'],
        'revenue_recognition_rate': revenue_data['recognized_revenue'] / revenue_data['performance_obligations_satisfied'], 
        'modification_frequency': revenue_data['modifications_count'] / revenue_data['active_contracts'],
        'days_to_recognition': revenue_data['avg_days_contract_to_revenue']
    }
    return kpis