foxhunt/fix_trading_engine_complete.py

#!/usr/bin/env python3
"""
Complete fix for trading_engine basic.rs file syntax errors
"""

import os

def fix_basic_rs():
    file_path = "/home/jgrusewski/Work/foxhunt/trading_engine/src/types/basic.rs"

    content = """//! Basic types - Clean imports from canonical common::types
//!
//! This module provides clean re-exports of types from the canonical common::types module.
//! All type definitions have been moved to common::types to establish a single source of truth.

#![deny(
    clippy::unwrap_used,
    clippy::expect_used,
    clippy::panic,
    clippy::unimplemented,
    clippy::unreachable
)]
#![warn(clippy::pedantic, clippy::nursery, clippy::perf)]

// ============================================================================
// CANONICAL TYPE IMPORTS - Single Source of Truth from common::types
// ============================================================================

// Re-export all canonical types from common crate
// Core Trading Types
pub use common::types::Order;
pub use common::types::OrderId;
pub use common::types::OrderSide;
pub use common::types::OrderStatus;
pub use common::types::OrderType;
pub use common::types::OrderRef;
pub use common::types::Price;
pub use common::types::Quantity;
pub use common::types::Volume;
pub use common::types::Symbol;
pub use common::types::Currency;
pub use common::types::TimeInForce;
pub use common::types::BrokerType;

// Market Data Types
pub use common::types::MarketTick;
pub use common::trading::TickType;
pub use common::trading::MarketRegime;
pub use common::types::TradingSignal;
pub use common::types::QuoteEvent;
pub use common::types::TradeEvent;
pub use common::types::BarEvent;
pub use common::types::Level2Update;
pub use common::types::PriceLevel;
pub use common::types::MarketStatus;
pub use common::types::ConnectionEvent;
pub use common::types::ConnectionStatus;
pub use common::types::ErrorEvent;
pub use common::types::OrderBookEvent;
pub use common::types::DataType;
pub use common::types::Subscription;
pub use common::types::MarketDataEvent;

// Identifiers
pub use common::types::TradeId;
pub use common::types::EventId;
pub use common::types::FillId;
pub use common::types::AggregateId;
pub use common::types::AssetId;
pub use common::types::ClientId;
pub use common::types::AccountId;

// Infrastructure Types
pub use common::types::ServiceId;
pub use common::types::ServiceStatus;
pub use common::types::ConfigVersion;
pub use common::types::RequestId;
pub use common::types::Timestamp;
pub use common::types::ConnectionInfo;
pub use common::types::ResourceLimits;

// Time Types
pub use common::types::HftTimestamp;
pub use common::types::GenericTimestamp;

// Financial Types
pub use common::types::Position;
pub use common::types::Execution;
pub use common::types::Money;

// Aggregate Types
pub use common::types::Aggregate;

// Import error type from crate for backward compatibility
use crate::types::errors::FoxhuntError;

// ============================================================================
// COMPATIBILITY BRIDGE FUNCTIONS
// ============================================================================

/// Bridge functions for existing code that expects TradingError static methods
/// These maintain backward compatibility while using the unified error system
#[derive(Debug)]
pub struct TradingError;

impl TradingError {
    /// Create an invalid price error
    #[must_use]
    pub fn invalid_price(value: f64, message: &str) -> FoxhuntError {
        FoxhuntError::InvalidPrice {
            value: value.to_string(),
            reason: message.to_owned(),
            symbol: None,
        }
    }

    /// Create an invalid quantity error
    #[must_use]
    pub fn invalid_quantity(value: f64, message: &str) -> FoxhuntError {
        FoxhuntError::InvalidQuantity {
            value: value.to_string(),
            reason: message.to_owned(),
            symbol: None,
        }
    }

    /// Create a division by zero error
    #[must_use]
    pub fn division_by_zero(message: &str) -> FoxhuntError {
        FoxhuntError::DivisionByZero {
            operation: message.to_owned(),
            context: None,
        }
    }
}

// ============================================================================
// TYPE ALIASES FOR BACKWARD COMPATIBILITY
// ============================================================================

// IMPORTANT: These are clean re-exports, not deprecated aliases
// They provide stable API for existing code while using canonical types

/// DateTime alias for convenience
pub use chrono::{DateTime, Utc};

/// Decimal type for financial calculations
pub use rust_decimal::Decimal;
pub use rust_decimal::prelude::FromPrimitive;

/// UUID for unique identifiers
pub use uuid::Uuid;

// ============================================================================
// PRELUDE FOR COMMON IMPORTS
// ============================================================================

/// Common types and traits that are frequently used together
pub mod prelude {
    pub use super::{
        Order, OrderId, OrderSide, OrderStatus, OrderType,
        Price, Quantity, Volume, Symbol, Currency, TimeInForce,
        MarketTick, TickType, MarketRegime, TradingSignal,
        TradeId, EventId, AccountId, HftTimestamp,
    };

    pub use chrono::{DateTime, Utc};
    pub use rust_decimal::Decimal;
    pub use uuid::Uuid;
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_canonical_imports() {
        // Test that canonical types are properly imported
        let price = Price::from_f64(100.0).expect("Valid price");
        assert!((price.to_f64() - 100.0).abs() < f64::EPSILON);

        let qty = Quantity::from_f64(50.0).expect("Valid quantity");
        assert!((qty.to_f64() - 50.0).abs() < f64::EPSILON);

        let symbol = Symbol::from("AAPL");
        assert_eq!(symbol.as_str(), "AAPL");

        let order_id = OrderId::new();
        assert!(order_id.value() > 0);
    }

    #[test]
    fn test_compatibility_bridges() {
        // Test that compatibility bridges work
        let error = TradingError::invalid_price(0.0, "Price cannot be zero");
        match error {
            FoxhuntError::InvalidPrice { value, reason, .. } => {
                assert_eq!(value, "0");
                assert_eq!(reason, "Price cannot be zero");
            }
            _ => panic!("Wrong error type"),
        }
    }
}
"""

    with open(file_path, 'w') as f:
        f.write(content)

    print(f"Completely rewrote {file_path} with clean syntax")

if __name__ == "__main__":
    fix_basic_rs()