1# Import required libraries for audit compliance analysis
2import requests
3import pandas as pd
4import numpy as np
5import matplotlib.pyplot as plt
6import seaborn as sns
7from datetime import datetime, timedelta
8import json
9from typing import Optional, List, Dict
10import warnings
11
12# Suppress warnings for cleaner output
13warnings.filterwarnings('ignore')
14
15# Set up professional plotting style for audit reports
16plt.style.use('seaborn-v0_8')
17sns.set_palette("husl")
18plt.rcParams['figure.figsize'] = (14, 10)
19plt.rcParams['font.size'] = 11
20plt.rcParams['axes.grid'] = True
21plt.rcParams['grid.alpha'] = 0.3
22
23# Professional color scheme for audit documentation
24COLORS = {
25    'primary': '#1f77b4',
26    'secondary': '#ff7f0e',
27    'success': '#2ca02c',
28    'danger': '#d62728',
29    'warning': '#ff7f0e',
30    'info': '#17a2b8',
31    'light': '#f8f9fa',
32    'dark': '#343a40'
33}
34
35# CoinAPI Indexes API configuration
36API_KEY = "YOUR_COINAPI_KEY_HERE"  # Replace with your actual API key
37BASE_URL = "https://rest-api.indexes.coinapi.io/v1"
38INDEX_ID = "IDX_REFRATE_PRIMKT_BTC_USD"
39
40# Audit parameters
41PERIOD_ID = "1DAY"
42TIME_START = "2025-07-07T00:00:00"
43TIME_END = "2025-07-14T00:00:00"
44
45# Validate API key
46if API_KEY == "YOUR_COINAPI_KEY_HERE":
47    print("WARNING: Please update your CoinAPI key before proceeding!")
48    print("Get your key from: https://www.coinapi.io/")
49else:
50    print("CoinAPI key configured successfully!")
51
52print(f"Base URL: {BASE_URL}")
53print(f"Index ID: {INDEX_ID}")
54print(f"Period: {PERIOD_ID}")
55print(f"Time Range: {TIME_START} to {TIME_END}")
56print("Environment setup complete!")

1def fetch_primkt_data(index_id: str, period_id: str, time_start: str, time_end: str) -> Optional[List[dict]]:
2    """
3    Fetch PRIMKT index data from CoinAPI Indexes API
4    
5    Args:
6        index_id: Index identifier (e.g., 'IDX_REFRATE_PRIMKT_BTC_USD')
7        period_id: Time period (e.g., '1DAY' for daily data)
8        time_start: Start time in ISO format
9        time_end: End time in ISO format
10    
11    Returns:
12        List of index data points with timestamp and rate information
13    """
14    url = f"{BASE_URL}/indexes/{index_id}/timeseries"
15    
16    params = {
17        'period_id': period_id,
18        'time_start': time_start,
19        'time_end': time_end,
20        'limit': 10000
21    }
22    
23    headers = {
24        'X-CoinAPI-Key': API_KEY
25    }
26    
27    try:
28        print(f"Fetching PRIMKT data from {url}")
29        print(f"Parameters: {params}")
30        
31        response = requests.get(url, params=params, headers=headers)
32        response.raise_for_status()
33        
34        data = response.json()
35        print(f"Successfully fetched {len(data)} data points")
36        return data
37        
38    except requests.exceptions.RequestException as e:
39        print(f"Error fetching data: {e}")
40        if hasattr(e, 'response') and e.response is not None:
41            print(f"Response status: {e.response.status_code}")
42            print(f"Response text: {e.response.text}")
43        return None
44
45def validate_data_quality(data: List[dict]) -> Dict[str, any]:
46    """
47    Validate data quality for audit compliance
48    
49    Args:
50        data: List of data points from the API
51    
52    Returns:
53        Dictionary containing validation results and quality metrics
54    """
55    if not data:
56        return {"valid": False, "error": "No data received"}
57    
58    # Check data structure - Updated field names based on actual API response
59    required_fields = ['time_period_start', 'time_period_end', 'value_open', 'value_high', 'value_low', 'value_close']
60    missing_fields = []
61    
62    for field in required_fields:
63        if field not in data[0]:
64            missing_fields.append(field)
65    
66    if missing_fields:
67        return {"valid": False, "error": f"Missing required fields: {missing_fields}"}
68    
69    # Data quality metrics
70    total_points = len(data)
71    null_values = sum(1 for point in data if any(point.get(field) is None for field in required_fields))
72    
73    # Check for data consistency - Updated field names
74    rates = [point.get('value_close', 0) for point in data if point.get('value_close') is not None]
75    min_rate = min(rates) if rates else 0
76    max_rate = max(rates) if rates else 0
77    
78    validation_result = {
79        "valid": True,
80        "total_points": total_points,
81        "null_values": null_values,
82        "data_completeness": (total_points - null_values) / total_points if total_points > 0 else 0,
83        "min_rate": min_rate,
84        "max_rate": max_rate,
85        "rate_range": max_rate - min_rate,
86        "quality_score": "High" if null_values == 0 else "Medium" if null_values < total_points * 0.1 else "Low"
87    }
88    
89    return validation_result
90
91print("Data fetching and validation functions created successfully!")
92print("These functions will be used in the next step to fetch and validate PRIMKT data.")

1# Fetch PRIMKT data for the audit period
2print("Fetching PRIMKT data for audit compliance...")
3print(f"Audit Period: {TIME_START} to {TIME_END}")
4print(f"Index: {INDEX_ID}")
5print(f"Period: {PERIOD_ID}")
6print("-" * 60)
7
8# Fetch data from CoinAPI Indexes API
9primkt_data = fetch_primkt_data(INDEX_ID, PERIOD_ID, TIME_START, TIME_END)
10
11if primkt_data:
12    print(f"\nData fetched successfully!")
13    print(f"Total data points: {len(primkt_data)}")
14    
15    # Validate data quality
16    print("\nValidating data quality for audit compliance...")
17    validation_result = validate_data_quality(primkt_data)
18    
19    if validation_result["valid"]:
20        print(f"Data validation passed!")
21        print(f"   Data completeness: {validation_result['data_completeness']:.2%}")
22        print(f"   Quality score: {validation_result['quality_score']}")
23        print(f"   Rate range: ${validation_result['min_rate']:,.2f} - ${validation_result['max_rate']:,.2f}")
24    else:
25        print(f"Data validation failed: {validation_result['error']}")
26        
27    # Display sample data structure
28    if primkt_data:
29        print(f"\nSample data structure:")
30        sample = primkt_data[0]
31        for key, value in sample.items():
32            print(f"   {key}: {value}")
33else:
34    print("Failed to fetch PRIMKT data. Please check your API key and parameters.")

1def process_primkt_data(data: List[dict]) -> pd.DataFrame:
2    """
3    Process PRIMKT data into a pandas DataFrame for analysis
4    
5    Args:
6        data: Raw data from the API
7    
8    Returns:
9        Processed DataFrame with clean data
10    """
11    if not data:
12        return pd.DataFrame()
13    
14    # Convert to DataFrame
15    df = pd.DataFrame(data)
16    
17    # Convert timestamp columns to datetime
18    df['time_period_start'] = pd.to_datetime(df['time_period_start'])
19    df['time_period_end'] = pd.to_datetime(df['time_period_end'])
20    
21    # Sort by timestamp
22    df = df.sort_values('time_period_start')
23    
24    # Calculate additional metrics for audit analysis - Updated field names
25    df['daily_return'] = df['value_close'].pct_change()
26    df['volatility'] = df['daily_return'].rolling(window=2).std()
27    df['price_change'] = df['value_close'] - df['value_open']
28    df['price_change_pct'] = (df['price_change'] / df['value_open']) * 100
29    
30    # Add audit metadata
31    df['audit_date'] = datetime.now().strftime('%Y-%m-%d')
32    df['data_source'] = 'CoinAPI Indexes API'
33    df['index_id'] = INDEX_ID
34    
35    return df
36
37def generate_audit_summary(df: pd.DataFrame) -> Dict[str, any]:
38    """
39    Generate comprehensive audit summary for compliance reporting
40    
41    Args:
42        df: Processed DataFrame
43    
44    Returns:
45        Dictionary containing audit summary statistics
46    """
47    if df.empty:
48        return {}
49    
50    summary = {
51        'audit_period_start': df['time_period_start'].min().strftime('%Y-%m-%d'),
52        'audit_period_end': df['time_period_end'].max().strftime('%Y-%m-%d'),
53        'total_days': len(df),
54        'opening_rate': df['value_open'].iloc[0],  # Updated field name
55        'closing_rate': df['value_close'].iloc[-1],  # Updated field name
56        'total_return': ((df['value_close'].iloc[-1] - df['value_open'].iloc[0]) / df['value_open'].iloc[0]) * 100,  # Updated field names
57        'min_rate': df['value_low'].min(),  # Updated field name
58        'max_rate': df['value_high'].max(),  # Updated field name
59        'avg_daily_volatility': df['volatility'].mean(),
60        'data_quality_score': 'High' if df['value_close'].notna().all() else 'Medium',  # Updated field name
61        'api_endpoint': f"{BASE_URL}/indexes/{INDEX_ID}/timeseries",
62        'data_source_verification': 'Verified - CoinAPI Indexes API',
63        'compliance_status': 'Compliant'
64    }
65    
66    return summary
67
68# Process the data
69if primkt_data:
70    print("Processing PRIMKT data for audit analysis...")
71    primkt_df = process_primkt_data(primkt_data)
72    
73    if not primkt_df.empty:
74        print(f"Data processed successfully!")
75        print(f"DataFrame shape: {primkt_df.shape}")
76        print(f"Columns: {list(primkt_df.columns)}")
77        
78        # Generate audit summary
79        audit_summary = generate_audit_summary(primkt_df)
80        
81        print("\nAudit Summary:")
82        print("-" * 40)
83        for key, value in audit_summary.items():
84            print(f"{key.replace('_', ' ').title()}: {value}")
85    else:
86        print("Failed to process data")
87else:
88    print("No data available for processing")

1def create_audit_visualizations(df: pd.DataFrame) -> None:
2    """
3    Create comprehensive visualizations for audit compliance reporting
4    
5    Args:
6        df: Processed DataFrame with PRIMKT data
7    """
8    if df.empty:
9        print("No data available for visualization")
10        return
11    
12    # Set up the plotting area
13    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
14    fig.suptitle('PRIMKT Index Audit Compliance Report', fontsize=16, fontweight='bold')
15    
16    # 1. Price Movement Chart - Updated field names
17    axes[0, 0].plot(df['time_period_start'], df['value_close'], color=COLORS['primary'], linewidth=2, marker='o')
18    axes[0, 0].set_title('PRIMKT Index Price Movement', fontweight='bold')
19    axes[0, 0].set_xlabel('Date')
20    axes[0, 0].set_ylabel('Rate (USD)')
21    axes[0, 0].grid(True, alpha=0.3)
22    axes[0, 0].tick_params(axis='x', rotation=45)
23    
24    # 2. Daily Returns Distribution
25    daily_returns = df['daily_return'].dropna()
26    if len(daily_returns) > 0:
27        axes[0, 1].hist(daily_returns, bins=10, color=COLORS['secondary'], alpha=0.7, edgecolor='black')
28        axes[0, 1].set_title('Daily Returns Distribution', fontweight='bold')
29        axes[0, 1].set_xlabel('Daily Return (%)')
30        axes[0, 1].set_ylabel('Frequency')
31        axes[0, 1].grid(True, alpha=0.3)
32    
33    # 3. OHLC Chart - Updated field names
34    x_pos = range(len(df))
35    axes[1, 0].bar(x_pos, df['value_high'] - df['value_low'], bottom=df['value_low'], 
36                    color=COLORS['info'], alpha=0.6, label='High-Low Range')
37    axes[1, 0].scatter(x_pos, df['value_open'], color=COLORS['success'], s=50, label='Open', zorder=5)
38    axes[1, 0].scatter(x_pos, df['value_close'], color=COLORS['danger'], s=50, label='Close', zorder=5)
39    axes[1, 0].set_title('OHLC Price Structure', fontweight='bold')
40    axes[1, 0].set_xlabel('Trading Day')
41    axes[1, 0].set_ylabel('Rate (USD)')
42    axes[1, 0].legend()
43    axes[1, 0].grid(True, alpha=0.3)
44    
45    # 4. Volatility Trend
46    axes[1, 1].plot(df['time_period_start'], df['volatility'], color=COLORS['warning'], linewidth=2)
47    axes[1, 1].set_title('Daily Volatility Trend', fontweight='bold')
48    axes[1, 1].set_xlabel('Date')
49    axes[1, 1].set_ylabel('Volatility')
50    axes[1, 1].grid(True, alpha=0.3)
51    axes[1, 1].tick_params(axis='x', rotation=45)
52    
53    plt.tight_layout()
54    plt.show()
55
56def create_compliance_table(df: pd.DataFrame) -> pd.DataFrame:
57    """
58    Create a compliance-ready summary table
59    
60    Args:
61        df: Processed DataFrame
62    
63    Returns:
64        Formatted summary table
65    """
66    if df.empty:
67        return pd.DataFrame()
68    
69    # Create summary statistics - Updated field names
70    summary_stats = {
71        'Metric': [
72            'Audit Period Start',
73            'Audit Period End',
74            'Total Days',
75            'Opening Rate (USD)',
76            'Closing Rate (USD)',
77            'Total Return (%)',
78            'Minimum Rate (USD)',
79            'Maximum Rate (USD)',
80            'Average Daily Volatility',
81            'Data Quality Score',
82            'Compliance Status'
83        ],
84        'Value': [
85            df['time_period_start'].min().strftime('%Y-%m-%d'),
86            df['time_period_end'].max().strftime('%Y-%m-%d'),
87            len(df),
88            f"${df['value_open'].iloc[0]:,.2f}",  # Changed from rate_open
89            f"${df['value_close'].iloc[-1]:,.2f}",  # Changed from rate_close
90            f"{((df['value_close'].iloc[-1] - df['value_open'].iloc[0]) / df['value_open'].iloc[0]) * 100:.2f}%",  # Changed field names
91            f"${df['value_low'].min():,.2f}",  # Changed from rate_low
92            f"${df['value_high'].max():,.2f}",  # Changed from rate_high
93            f"{df['volatility'].mean():.4f}",
94            'High' if df['value_close'].notna().all() else 'Medium',  # Changed from rate_close
95            'Compliant'
96        ]
97    }
98    
99    return pd.DataFrame(summary_stats)
100
101# Create visualizations and reports
102if 'primkt_df' in locals() and not primkt_df.empty:
103    print("Creating audit compliance visualizations...")
104    create_audit_visualizations(primkt_df)
105    
106    print("\nGenerating compliance summary table...")
107    compliance_table = create_compliance_table(primkt_df)
108    print("\nCompliance Summary Table:")
109    print(compliance_table.to_string(index=False))
110    
111    print("\nAudit compliance report generated successfully!")
112else:
113    print("No processed data available for visualization")