corally 1.0.0__py3-none-any.whl

corally/__init__.py

@@ -0,0 +1,36 @@
+"""
+Corally - A comprehensive calculator suite with GUI and API support.
+
+This package provides:
+- Basic arithmetic operations with logging
+- Currency conversion (static and live rates)
+- Interest calculations with multiple methods
+- Modern GUI interface
+- REST API for currency conversion
+- Command-line interface
+
+Example usage:
+    >>> from corally import CalculatorCore, CurrencyConverter
+    >>> calc = CalculatorCore()
+    >>> result = calc.add(5, 3)
+    >>> print(result)  # 8.0
+    
+    >>> converter = CurrencyConverter()
+    >>> usd = converter.eur_to_usd(100)
+    >>> print(usd)  # 117.0
+"""
+
+from .core.calculator import CalculatorCore, CurrencyConverter, InterestCalculator
+
+__version__ = "2.0.0"
+__author__ = "Corally Team"
+__email__ = "contact@corally.dev"
+__description__ = "A comprehensive calculator suite with GUI and API support"
+
+# Make main classes available at package level
+__all__ = [
+    "CalculatorCore",
+    "CurrencyConverter", 
+    "InterestCalculator",
+    "__version__",
+]

corally/api/__init__.py

@@ -0,0 +1,8 @@
+"""
+API modules for Corally calculator suite.
+"""
+
+from .server import create_app, start_server
+from .free_server import create_free_app, start_free_server
+
+__all__ = ["create_app", "start_server", "create_free_app", "start_free_server"]

corally/api/free_server.py

@@ -0,0 +1,259 @@
+import os
+import time
+import csv
+import httpx
+import logging
+from pathlib import Path
+from fastapi import FastAPI, HTTPException, Query
+
+# Create data directory if it doesn't exist
+data_dir = Path("data")
+data_dir.mkdir(exist_ok=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    filename=str(data_dir / "api.log"),
+    filemode="w",
+    format="%(asctime)s %(levelname)s %(message)s"
+)
+
+# Free API endpoints that don't require API keys
+FREE_API_ENDPOINTS = [
+    "https://api.exchangerate-api.com/v4/latest/",  # Free, no key required
+    "https://api.fixer.io/latest?access_key=",      # Backup (requires key)
+]
+
+CACHE_FILE = str(data_dir / "cache.csv")
+CACHE_TTL = 3600  # 60 minutes
+
+app = FastAPI(title="Free Currency Converter with CSV Cache")
+
+# Cache: Memory + CSV
+CACHE: dict = {}
+
+def get_cache_key(from_currency: str, to_currency: str, amount: float) -> str:
+    return f"{from_currency.upper()}-{to_currency.upper()}-{amount}"
+
+def load_cache():
+    """Load existing cache entries from CSV"""
+    if not os.path.exists(CACHE_FILE):
+        return
+    try:
+        with open(CACHE_FILE, mode="r", newline="") as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                key = get_cache_key(row["from"], row["to"], float(row["amount"]))
+                CACHE[key] = {
+                    "timestamp": float(row["timestamp"]),
+                    "data": {
+                        "from": row["from"],
+                        "to": row["to"],
+                        "amount": float(row["amount"]),
+                        "result": float(row["result"]),
+                        "info": {
+                            "rate": float(row["rate"]) if row["rate"] not in (None, '', 'None') else None
+                        }
+                    }
+                }
+    except Exception as e:
+        logging.error(f"Error loading cache: {e}")
+
+def save_cache():
+    """Write cache to CSV file"""
+    try:
+        with open(CACHE_FILE, mode="w", newline="") as f:
+            fieldnames = ["from", "to", "amount", "result", "rate", "timestamp"]
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            for entry in CACHE.values():
+                data = entry["data"]
+                writer.writerow({
+                    "from": data["from"],
+                    "to": data["to"],
+                    "amount": data["amount"],
+                    "result": data["result"],
+                    "rate": data["info"].get("rate", None),
+                    "timestamp": entry["timestamp"]
+                })
+    except Exception as e:
+        logging.error(f"Error saving cache: {e}")
+
+def get_cache(key: str):
+    item = CACHE.get(key)
+    if item:
+        if time.time() - item["timestamp"] < CACHE_TTL:
+            item["timestamp"] = time.time()
+            save_cache()
+            return item["data"]
+        else:
+            del CACHE[key]
+            save_cache()
+    return None
+
+def set_cache(key: str, value: dict):
+    CACHE[key] = {"timestamp": time.time(), "data": value}
+    save_cache()
+
+def cleanup_cache():
+    """Remove all expired cache entries"""
+    now = time.time()
+    keys_to_delete = [key for key, entry in CACHE.items() if now - entry["timestamp"] >= CACHE_TTL]
+    for key in keys_to_delete:
+        del CACHE[key]
+    if keys_to_delete:
+        save_cache()
+
+async def get_exchange_rate(from_currency: str, to_currency: str):
+    """Get exchange rate using free API"""
+    from_currency = from_currency.upper()
+    to_currency = to_currency.upper()
+
+    logging.info(f"Getting exchange rate: {from_currency} -> {to_currency}")
+
+    # Try the free API first
+    try:
+        async with httpx.AsyncClient() as client:
+            url = f"https://api.exchangerate-api.com/v4/latest/{from_currency}"
+            logging.info(f"Making request to: {url}")
+
+            response = await client.get(url, timeout=15)
+            logging.info(f"Response status: {response.status_code}")
+
+            if response.status_code == 200:
+                data = response.json()
+                rates = data.get("rates", {})
+                logging.info(f"Got {len(rates)} exchange rates")
+
+                if to_currency in rates:
+                    rate = rates[to_currency]
+                    logging.info(f"Exchange rate {from_currency}/{to_currency}: {rate}")
+                    return rate
+                else:
+                    available_currencies = list(rates.keys())[:10]  # Show first 10
+                    error_msg = f"Currency {to_currency} not supported. Available: {available_currencies}..."
+                    logging.error(error_msg)
+                    raise HTTPException(status_code=400, detail=error_msg)
+            else:
+                error_msg = f"External API returned status {response.status_code}: {response.text}"
+                logging.error(error_msg)
+                raise HTTPException(status_code=response.status_code, detail=error_msg)
+
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    except httpx.TimeoutException as e:
+        error_msg = f"Request timeout: {str(e)}"
+        logging.error(error_msg)
+        raise HTTPException(status_code=504, detail=error_msg)
+    except httpx.RequestError as e:
+        error_msg = f"Network error: {str(e)}"
+        logging.error(error_msg)
+        raise HTTPException(status_code=503, detail=error_msg)
+    except Exception as e:
+        error_msg = f"Unexpected error: {str(e)}"
+        logging.error(error_msg)
+        raise HTTPException(status_code=500, detail=error_msg)
+
+# Load cache on startup
+load_cache()
+cleanup_cache()
+
+@app.get("/convert")
+async def convert(
+    from_currency: str,
+    to_currency: str,
+    amount: str = Query(...)
+):
+    logging.info(f"Convert request: {amount} {from_currency} -> {to_currency}")
+
+    # Validate and parse amount
+    try:
+        amount_float = float(amount.replace(",", "."))
+        if amount_float <= 0:
+            raise ValueError("Amount must be positive")
+    except ValueError as e:
+        error_msg = f"Invalid amount '{amount}': {str(e)}"
+        logging.error(error_msg)
+        raise HTTPException(status_code=400, detail=error_msg)
+
+    # Validate currencies
+    if not from_currency or not to_currency:
+        raise HTTPException(status_code=400, detail="Both from_currency and to_currency are required")
+
+    if len(from_currency) != 3 or len(to_currency) != 3:
+        raise HTTPException(status_code=400, detail="Currency codes must be 3 letters (e.g., EUR, USD)")
+
+    cache_key = get_cache_key(from_currency, to_currency, amount_float)
+    logging.info(f"Cache key: {cache_key}")
+
+    # 1. Check cache
+    try:
+        cached = get_cache(cache_key)
+        if cached:
+            logging.info("Returning cached result")
+            return {"cached": True, **cached}
+    except Exception as e:
+        logging.warning(f"Cache lookup failed: {e}")
+
+    # 2. Get exchange rate
+    try:
+        rate = await get_exchange_rate(from_currency, to_currency)
+    except HTTPException:
+        # Re-raise HTTP exceptions
+        raise
+    except Exception as e:
+        error_msg = f"Failed to get exchange rate: {str(e)}"
+        logging.error(error_msg)
+        raise HTTPException(status_code=500, detail=error_msg)
+
+    # 3. Calculate result
+    try:
+        result_amount = amount_float * rate
+
+        result = {
+            "from": from_currency.upper(),
+            "to": to_currency.upper(),
+            "amount": amount_float,
+            "result": round(result_amount, 2),
+            "info": {
+                "rate": rate
+            }
+        }
+
+        logging.info(f"Conversion result: {result}")
+
+        # 4. Save to cache
+        try:
+            set_cache(cache_key, result)
+        except Exception as e:
+            logging.warning(f"Failed to save to cache: {e}")
+
+        return {"cached": False, **result}
+
+    except Exception as e:
+        error_msg = f"Calculation failed: {str(e)}"
+        logging.error(error_msg)
+        raise HTTPException(status_code=500, detail=error_msg)
+
+@app.get("/")
+async def root():
+    return {"message": "Free Currency Converter API", "status": "running"}
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "cache_entries": len(CACHE)}
+
+
+def create_free_app() -> FastAPI:
+    """Create and return the free FastAPI app instance."""
+    return app
+
+
+def start_free_server(host: str = "127.0.0.1", port: int = 8000) -> None:
+    """Start the free API server."""
+    import uvicorn
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    start_free_server()

corally/api/server.py

@@ -0,0 +1,190 @@
+import os
+import time
+import csv
+import httpx
+import logging
+from pathlib import Path
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Query
+
+# Create data directory if it doesn't exist
+data_dir = Path("data")
+data_dir.mkdir(exist_ok=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    filename=str(data_dir / "api.log"),      # Log file name
+    filemode="w",            # Overwrite log file on each start
+    format="%(asctime)s %(levelname)s %(message)s"
+)
+
+# .env laden
+load_dotenv()
+API_KEY = os.getenv("API_KEY")
+# Note: API_KEY will be checked when the server starts, not at import time
+
+BASE_URL = "https://api.exchangerate.host/convert"
+CACHE_FILE = str(data_dir / "cache.csv")
+CACHE_TTL = 3600  # 60 Minuten
+
+app = FastAPI(title="Währungsrechner mit CSV-Cache")
+
+# -----------------------------
+# Cache: Speicher im Speicher + CSV
+# -----------------------------
+CACHE: dict = {}
+
+def get_cache_key(from_currency: str, to_currency: str, amount: float) -> str:
+    return f"{from_currency.upper()}-{to_currency.upper()}-{amount}"
+
+def load_cache():
+    """Lädt vorhandene Cache-Einträge aus der CSV"""
+    if not os.path.exists(CACHE_FILE):
+        return
+    with open(CACHE_FILE, mode="r", newline="") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            key = get_cache_key(row["from"], row["to"], float(row["amount"]))
+            CACHE[key] = {
+                "timestamp": float(row["timestamp"]),
+                "data": {
+                    "from": row["from"],
+                    "to": row["to"],
+                    "amount": float(row["amount"]),
+                    "result": float(row["result"]),
+                    "info": {
+                        "rate": float(row["rate"]) if row["rate"] not in (None, '', 'None') else None
+                    }
+                }
+            }
+
+def save_cache():
+    """Schreibt den Cache in die CSV-Datei"""
+    with open(CACHE_FILE, mode="w", newline="") as f:
+        fieldnames = ["from", "to", "amount", "result", "rate", "timestamp"]
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for entry in CACHE.values():
+            data = entry["data"]
+            writer.writerow({
+                "from": data["from"],
+                "to": data["to"],
+                "amount": data["amount"],
+                "result": data["result"],
+                "rate": data["info"].get("rate", None),  # <-- Fix here
+                "timestamp": entry["timestamp"]
+            })
+
+def get_cache(key: str):
+    item = CACHE.get(key)
+    if item:
+        if time.time() - item["timestamp"] < CACHE_TTL:
+            # Update the timestamp to extend TTL
+            item["timestamp"] = time.time()
+            save_cache()
+            return item["data"]
+        else:
+            del CACHE[key]
+            save_cache()
+    return None
+
+def set_cache(key: str, value: dict):
+    CACHE[key] = {"timestamp": time.time(), "data": value}
+    save_cache()
+    
+    
+def cleanup_cache():
+    """Entfernt alle abgelaufenen Cache-Einträge."""
+    now = time.time()
+    keys_to_delete = [key for key, entry in CACHE.items() if now - entry["timestamp"] >= CACHE_TTL]
+    for key in keys_to_delete:
+        del CACHE[key]
+    if keys_to_delete:
+        save_cache()
+
+# Lade Cache beim Start und bereinige abgelaufene Einträge
+load_cache()
+cleanup_cache()
+# -----------------------------
+# API-Endpunkt
+# -----------------------------
+@app.get("/convert")
+async def convert(
+    from_currency: str,
+    to_currency: str,
+    amount: str = Query(...)
+):
+    # Allow comma as decimal separator
+    try:
+        amount_float = float(amount.replace(",", "."))
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Ungültiger Betrag. Bitte Zahl mit Punkt oder Komma eingeben.")
+
+    cache_key = get_cache_key(from_currency, to_currency, amount_float)
+
+    # 1. Cache prüfen
+    cached = get_cache(cache_key)
+    if cached:
+        return {"cached": True, **cached}
+
+    # 2. API-Aufruf
+    params = {
+        "access_key": API_KEY,
+        "from": from_currency.upper(),
+        "to": to_currency.upper(),
+        "amount": amount_float
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(BASE_URL, params=params)
+
+    logging.info("API response: %s", response.json())
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail=f"API-Anfrage fehlgeschlagen: {response.status_code}")
+
+    data = response.json()
+    if not data.get("success", False):
+        err = data.get("error", {})
+        raise HTTPException(status_code=400, detail=f"API-Fehler: {err}")
+
+    # Extract rate safely
+    rate = None
+    if "info" in data and isinstance(data["info"], dict):
+        rate = data["info"].get("rate")
+        if rate is None:
+            rate = data["info"].get("quote")
+    elif "rate" in data:
+        rate = data.get("rate")
+
+    result = {
+        "from": from_currency.upper(),
+        "to": to_currency.upper(),
+        "amount": amount_float,
+        "result": data.get("result"),
+        "info": {
+            "rate": rate
+        }
+    }
+
+    # 3. Cache speichern
+    set_cache(cache_key, result)
+
+    return {"cached": False, **result}
+
+
+def create_app() -> FastAPI:
+    """Create and return the FastAPI app instance."""
+    return app
+
+
+def start_server(host: str = "127.0.0.1", port: int = 8000) -> None:
+    """Start the API server."""
+    if not API_KEY:
+        raise RuntimeError("Missing API_KEY in environment variables. Please set API_KEY in .env file.")
+    import uvicorn
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    start_server()

corally/cli/__init__.py

@@ -0,0 +1,9 @@
+"""
+Command-line interface modules for Corally calculator suite.
+"""
+
+from .main import main_cli
+from .calculator import calculator_cli
+from .currency import currency_cli
+
+__all__ = ["main_cli", "calculator_cli", "currency_cli"]

corally/cli/calculator.py

@@ -0,0 +1,59 @@
+"""
+Calculator CLI module for Corally.
+"""
+
+from ..core import CalculatorCore
+
+
+def calculator_cli() -> None:
+    """Standalone calculator CLI interface."""
+    calc = CalculatorCore()
+    print("🧮 Corally Calculator")
+    print("=" * 20)
+    
+    while True:
+        print("\nOperations:")
+        print("1: Addition")
+        print("2: Subtraction")
+        print("3: Multiplication")
+        print("4: Division")
+        print("5: Exit")
+        
+        try:
+            choice = int(input("\nSelect operation (1-5): "))
+        except ValueError:
+            print("❌ Invalid input. Please enter a number.")
+            continue
+        
+        if choice == 5:
+            print("👋 Calculator closed.")
+            break
+        elif choice not in [1, 2, 3, 4]:
+            print("❌ Invalid choice. Please select 1-5.")
+            continue
+        
+        try:
+            a = float(input("Enter first number: "))
+            b = float(input("Enter second number: "))
+        except ValueError:
+            print("❌ Invalid number input.")
+            continue
+        
+        result = None
+        if choice == 1:
+            result = calc.add(a, b)
+            print(f"✅ {a} + {b} = {result}")
+        elif choice == 2:
+            result = calc.subtract(a, b)
+            print(f"✅ {a} - {b} = {result}")
+        elif choice == 3:
+            result = calc.multiply(a, b)
+            print(f"✅ {a} × {b} = {result}")
+        elif choice == 4:
+            result = calc.divide(a, b)
+            if result is not None:
+                print(f"✅ {a} ÷ {b} = {result}")
+
+
+if __name__ == "__main__":
+    calculator_cli()

corally/cli/currency.py

@@ -0,0 +1,65 @@
+"""
+Currency converter CLI module for Corally.
+"""
+
+from ..core import CurrencyConverter
+
+
+def currency_cli() -> None:
+    """Standalone currency converter CLI interface."""
+    converter = CurrencyConverter()
+    print("💱 Corally Currency Converter")
+    print("=" * 30)
+    
+    while True:
+        print("\nAvailable conversions:")
+        print("1: EUR to USD")
+        print("2: USD to EUR")
+        print("3: EUR to GBP")
+        print("4: GBP to EUR")
+        print("5: EUR to JPY")
+        print("6: JPY to EUR")
+        print("7: Exit")
+        
+        try:
+            choice = int(input("\nSelect conversion (1-7): "))
+        except ValueError:
+            print("❌ Invalid input. Please enter a number.")
+            continue
+        
+        if choice == 7:
+            print("👋 Currency converter closed.")
+            break
+        elif choice not in range(1, 7):
+            print("❌ Invalid choice. Please select 1-7.")
+            continue
+        
+        try:
+            amount = float(input("Enter amount: "))
+        except ValueError:
+            print("❌ Invalid amount.")
+            continue
+        
+        result = None
+        if choice == 1:
+            result = converter.eur_to_usd(amount)
+            print(f"✅ {amount} EUR = {result} USD")
+        elif choice == 2:
+            result = converter.usd_to_eur(amount)
+            print(f"✅ {amount} USD = {result} EUR")
+        elif choice == 3:
+            result = converter.eur_to_gbp(amount)
+            print(f"✅ {amount} EUR = {result} GBP")
+        elif choice == 4:
+            result = converter.gbp_to_eur(amount)
+            print(f"✅ {amount} GBP = {result} EUR")
+        elif choice == 5:
+            result = converter.eur_to_jpy(amount)
+            print(f"✅ {amount} EUR = {result} JPY")
+        elif choice == 6:
+            result = converter.jpy_to_eur(amount)
+            print(f"✅ {amount} JPY = {result} EUR")
+
+
+if __name__ == "__main__":
+    currency_cli()