Technology Stack

# Python 3.10+ features in use
from typing import Optional

# Union types with | operator
def calculate_odds(probability: float | None) -> dict | str:
    match probability:
        case float(p) if 0 <= p <= 1:
            return {"odds": 1/p, "confidence": "high"}
        case None:
            return "insufficient_data"
        case _:
            return "invalid_probability"

# Example: PyQt connecting to FastAPI backend
from PyQt5.QtWidgets import QMainWindow
from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest
from PyQt5.QtCore import QUrl

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.network_manager = QNetworkAccessManager()
        self.network_manager.finished.connect(self.on_response)
        
    def fetch_match_data(self, match_id: str):
        url = QUrl(f"http://localhost:8000/api/matches/{match_id}")
        request = QNetworkRequest(url)
        self.network_manager.get(request)

# src/main/python/main.py
from fastapi import FastAPI, Depends
from pydantic import BaseModel
from typing import List

app = FastAPI(
    title="OddsEngine API",
    description="Probabilistic analysis API for tennis betting",
    version="1.0.0"
)

class CombinedBetRequest(BaseModel):
    match_ids: List[str]
    bet_type: str = "winner"

class ProbabilityResponse(BaseModel):
    individual_probabilities: List[float]
    combined_probability: float
    confidence_score: float

@app.post("/api/bets/analyze", response_model=ProbabilityResponse)
async def analyze_combined_bet(request: CombinedBetRequest):
    """Calculate probability for combined bet across multiple matches"""
    # Async processing allows handling multiple requests concurrently
    probabilities = await fetch_match_probabilities(request.match_ids)
    return calculate_combined_odds(probabilities)

# src/main/python/services/tennis_api_client.py
import httpx
from typing import Optional

class TennisAPIClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        # Reusable client with connection pooling
        self.client = httpx.AsyncClient(
            base_url="https://api-tennis.com/v1",
            timeout=10.0,
            limits=httpx.Limits(max_keepalive_connections=5)
        )
        
    async def get_player_stats(self, player_id: str) -> dict:
        """Fetch player statistics with automatic retry on failure"""
        try:
            response = await self.client.get(
                f"/players/{player_id}/stats",
                headers={"X-API-Key": self.api_key}
            )
            response.raise_for_status()
            return response.json()
        except httpx.HTTPError as e:
            # Fallback to mock data provider
            return await self._get_mock_player_stats(player_id)

# src/main/python/engine/probability_calculator.py
import pandas as pd
import numpy as np

class ProbabilityEngine:
    def __init__(self, match_history: pd.DataFrame):
        self.match_history = match_history
        
    def calculate_win_probability(self, player_id: str, opponent_id: str) -> float:
        """
        Calculate win probability based on:
        - Head-to-head record
        - Recent form (last 10 matches)
        - Surface performance
        """
        # Filter player's recent matches
        player_matches = self.match_history[
            self.match_history['player_id'] == player_id
        ].tail(10)
        
        # Calculate win rate
        win_rate = player_matches['result'].value_counts(normalize=True).get('win', 0)
        
        # Adjust for opponent strength
        opponent_ranking = self._get_player_ranking(opponent_id)
        adjusted_probability = win_rate * self._ranking_adjustment(opponent_ranking)
        
        return float(np.clip(adjusted_probability, 0.1, 0.9))

-- Example: Query for player match history
SELECT 
    m.match_id,
    m.match_date,
    m.tournament,
    m.surface,
    m.result,
    p.player_name,
    o.player_name AS opponent_name
FROM matches m
JOIN players p ON m.player_id = p.player_id
JOIN players o ON m.opponent_id = o.player_id
WHERE m.player_id = :player_id
ORDER BY m.match_date DESC
FETCH FIRST 50 ROWS ONLY;

# docker-compose.yml (conceptual structure)
version: '3.8'

services:
  backend:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    environment:
      DATABASE_URL: oracle://oddsengine:${DB_PASSWORD}@database:1521/xe
      API_TENNIS_KEY: ${API_TENNIS_KEY}
    volumes:
      - ./conf:/app/conf:ro
    depends_on:
      - database
      
  database:
    image: container-registry.oracle.com/database/express:21.3.0-xe
    ports:
      - "1521:1521"
    environment:
      ORACLE_PWD: ${DB_PASSWORD}
    volumes:
      - oracle_data:/opt/oracle/oradata

volumes:
  oracle_data:

FROM python:3.10-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    gcc \
    libaio1 \
    && rm -rf /var/lib/apt/lists/*

# Install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY src/ ./src/
COPY conf/ ./conf/

# Run FastAPI with Uvicorn
CMD ["uvicorn", "src.main.python.main:app", "--host", "0.0.0.0", "--port", "8000"]

# src/test/python/test_probability_engine.py
import pytest
from engine.probability_calculator import ProbabilityEngine

@pytest.mark.asyncio
async def test_combined_probability_calculation():
    engine = ProbabilityEngine()
    bets = [
        {"match_id": "1", "probability": 0.8},
        {"match_id": "2", "probability": 0.7},
        {"match_id": "3", "probability": 0.6}
    ]
    
    result = engine.calculate_combined_probability(bets)
    
    # 0.8 * 0.7 * 0.6 = 0.336
    assert abs(result["combined_probability"] - 0.336) < 0.001