unrealon 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

unrealon_driver/src/utils/time_formatter.py

@@ -1,338 +0,0 @@
-"""
-Time Formatter Utility - UnrealOn Driver v3.0
-
-Beautiful time formatting for CLI applications with HH:MM:SS display,
-duration calculations, and human-readable intervals.
-"""
-
-import asyncio
-import time
-from datetime import datetime, timedelta
-from typing import Optional, Union
-
-
-class TimeFormatter:
-    """
-    Beautiful time formatting utility for CLI applications.
-    
-    Features:
-    - HH:MM:SS format display
-    - Duration calculations
-    - Human-readable intervals
-    - Elapsed time tracking
-    - Next run time display
-    """
-    
-    @staticmethod
-    def format_duration(seconds: Union[int, float]) -> str:
-        """
-        Format duration in HH:MM:SS format.
-        
-        Args:
-            seconds: Duration in seconds
-            
-        Returns:
-            Formatted string like "01:23:45" or "00:05:30"
-        """
-        if seconds < 0:
-            return "00:00:00"
-            
-        hours = int(seconds // 3600)
-        minutes = int((seconds % 3600) // 60)
-        secs = int(seconds % 60)
-        
-        return f"{hours:02d}:{minutes:02d}:{secs:02d}"
-    
-    @staticmethod
-    def format_time(dt: Optional[datetime] = None) -> str:
-        """
-        Format datetime in HH:MM:SS format.
-        
-        Args:
-            dt: Datetime object (current time if None)
-            
-        Returns:
-            Time string like "14:30:45"
-        """
-        if dt is None:
-            dt = datetime.now()
-        return dt.strftime("%H:%M:%S")
-    
-    @staticmethod
-    def format_datetime(dt: Optional[datetime] = None) -> str:
-        """
-        Format datetime in full format.
-        
-        Args:
-            dt: Datetime object (current time if None)
-            
-        Returns:
-            Full datetime string like "2024-01-15 14:30:45"
-        """
-        if dt is None:
-            dt = datetime.now()
-        return dt.strftime("%Y-%m-%d %H:%M:%S")
-    
-    @staticmethod
-    def parse_interval(interval: str) -> int:
-        """
-        Parse human-readable interval to seconds.
-        
-        Args:
-            interval: Human-readable interval like "30m", "1h", "daily"
-            
-        Returns:
-            Interval in seconds
-            
-        Raises:
-            ValueError: If interval format is invalid
-        """
-        interval = interval.lower().strip()
-        
-        # Natural language
-        interval_map = {
-            "minutely": 60,
-            "hourly": 3600,
-            "daily": 86400,
-            "weekly": 604800,
-            "monthly": 2592000,  # 30 days
-        }
-        
-        if interval in interval_map:
-            return interval_map[interval]
-        
-        # Time units with numbers
-        if interval.endswith('s'):
-            return int(interval[:-1])
-        elif interval.endswith('m'):
-            return int(interval[:-1]) * 60
-        elif interval.endswith('h'):
-            return int(interval[:-1]) * 3600
-        elif interval.endswith('d'):
-            return int(interval[:-1]) * 86400
-        elif interval.endswith('w'):
-            return int(interval[:-1]) * 604800
-        elif interval.endswith('mo'):
-            return int(interval[:-2]) * 2592000
-        
-        # Try parsing as plain seconds
-        try:
-            return int(interval)
-        except ValueError:
-            raise ValueError(f"Invalid interval format: {interval}")
-    
-    @staticmethod
-    def format_interval(seconds: int) -> str:
-        """
-        Format seconds back to human-readable interval.
-        
-        Args:
-            seconds: Interval in seconds
-            
-        Returns:
-            Human-readable string like "30m", "2h", "1d"
-        """
-        if seconds < 60:
-            return f"{seconds}s"
-        elif seconds < 3600:
-            return f"{seconds // 60}m"
-        elif seconds < 86400:
-            return f"{seconds // 3600}h"
-        elif seconds < 604800:
-            return f"{seconds // 86400}d"
-        else:
-            return f"{seconds // 604800}w"
-    
-    @staticmethod
-    def time_until(target_time: datetime) -> str:
-        """
-        Calculate time remaining until target time.
-        
-        Args:
-            target_time: Target datetime
-            
-        Returns:
-            Time remaining in HH:MM:SS format
-        """
-        now = datetime.now()
-        if target_time <= now:
-            return "00:00:00"
-        
-        diff = target_time - now
-        return TimeFormatter.format_duration(diff.total_seconds())
-    
-    @staticmethod
-    def elapsed_since(start_time: float) -> str:
-        """
-        Calculate elapsed time since start timestamp.
-        
-        Args:
-            start_time: Start timestamp from time.time()
-            
-        Returns:
-            Elapsed time in HH:MM:SS format
-        """
-        elapsed = time.time() - start_time
-        return TimeFormatter.format_duration(elapsed)
-    
-    @staticmethod
-    async def countdown_sleep(duration_seconds: int, callback=None, interval: float = 1.0):
-        """
-        Sleep with live countdown display that updates in place.
-        
-        Args:
-            duration_seconds: Total sleep duration in seconds
-            callback: Optional callback function to call with remaining time
-            interval: Update interval in seconds (default 1.0)
-        """
-        import sys
-        
-        slept = 0
-        while slept < duration_seconds:
-            remaining = duration_seconds - slept
-            
-            if remaining > 0 and callback:
-                remaining_time = TimeFormatter.format_duration(remaining)
-                current_time = TimeFormatter.format_time()
-                # Use \r to return to beginning of line and overwrite
-                callback(current_time, remaining_time, remaining, update_in_place=True)
-            
-            sleep_chunk = min(interval, duration_seconds - slept)
-            await asyncio.sleep(sleep_chunk)
-            slept += sleep_chunk
-        
-        # Print newline after countdown finishes
-        if callback:
-            print()  # Move to next line when done
-
-
-class ScheduleTimer:
-    """
-    Timer for scheduled operations with beautiful display.
-    
-    Features:
-    - Real-time countdown
-    - Elapsed time tracking
-    - Next run calculation
-    - Progress display
-    """
-    
-    def __init__(self, interval: str):
-        """
-        Initialize timer with interval.
-        
-        Args:
-            interval: Human-readable interval like "30m"
-        """
-        self.interval = interval
-        self.interval_seconds = TimeFormatter.parse_interval(interval)
-        self.start_time = time.time()
-        self.last_run = None
-        self.next_run = None
-        self.run_count = 0
-        
-    def start_run(self):
-        """Mark start of new run."""
-        self.last_run = datetime.now()
-        self.next_run = self.last_run + timedelta(seconds=self.interval_seconds)
-        self.run_count += 1
-    
-    def get_elapsed_total(self) -> str:
-        """Get total elapsed time since timer start."""
-        return TimeFormatter.elapsed_since(self.start_time)
-    
-    def get_time_until_next(self) -> str:
-        """Get time remaining until next run."""
-        if self.next_run is None:
-            return "00:00:00"
-        return TimeFormatter.time_until(self.next_run)
-    
-    def get_next_run_time(self) -> str:
-        """Get next run time formatted."""
-        if self.next_run is None:
-            return "Not scheduled"
-        return TimeFormatter.format_datetime(self.next_run)
-    
-    def get_status_display(self) -> str:
-        """
-        Get beautiful status display.
-        
-        Returns:
-            Multi-line status string with timer info
-        """
-        lines = [
-            f"⏱️  Interval: {self.interval} ({TimeFormatter.format_interval(self.interval_seconds)})",
-            f"🔄 Runs completed: {self.run_count}",
-            f"⏰ Total elapsed: {self.get_elapsed_total()}",
-        ]
-        
-        if self.next_run:
-            lines.extend([
-                f"🕐 Next run at: {TimeFormatter.format_time(self.next_run)}",
-                f"⏳ Time remaining: {self.get_time_until_next()}",
-            ])
-        
-        return "\n".join(lines)
-
-
-class DaemonTimer:
-    """
-    Timer for daemon operations with uptime tracking.
-    
-    Features:
-    - Uptime display
-    - Heartbeat counting
-    - Status monitoring
-    - Connection time tracking
-    """
-    
-    def __init__(self):
-        """Initialize daemon timer."""
-        self.start_time = time.time()
-        self.heartbeat_count = 0
-        self.last_heartbeat = None
-        self.connection_time = None
-        
-    def heartbeat(self):
-        """Record heartbeat."""
-        self.heartbeat_count += 1
-        self.last_heartbeat = datetime.now()
-    
-    def connect(self):
-        """Mark connection established."""
-        self.connection_time = datetime.now()
-    
-    def get_uptime(self) -> str:
-        """Get daemon uptime."""
-        return TimeFormatter.elapsed_since(self.start_time)
-    
-    def get_connection_duration(self) -> str:
-        """Get connection duration."""
-        if self.connection_time is None:
-            return "Not connected"
-        
-        elapsed = time.time() - self.connection_time.timestamp()
-        return TimeFormatter.format_duration(elapsed)
-    
-    def get_status_display(self) -> str:
-        """
-        Get beautiful daemon status display.
-        
-        Returns:
-            Multi-line status string with daemon info
-        """
-        lines = [
-            f"⏰ Uptime: {self.get_uptime()}",
-            f"💓 Heartbeats: {self.heartbeat_count}",
-        ]
-        
-        if self.last_heartbeat:
-            lines.append(f"🕐 Last heartbeat: {TimeFormatter.format_time(self.last_heartbeat)}")
-        
-        if self.connection_time:
-            lines.extend([
-                f"🔌 Connected at: {TimeFormatter.format_time(self.connection_time)}",
-                f"📡 Connection time: {self.get_connection_duration()}",
-            ])
-        
-        return "\n".join(lines)

unrealon_llm/README.md

@@ -1,44 +0,0 @@
-# UnrealOn LLM SDK
-
-AI-powered modular platform for content processing with cost control and accuracy guarantees.
-
-## Features
-
-- **Universal LLM Client**: Support for OpenRouter, OpenAI, Anthropic
-- **HTML Pattern Detection**: AI-powered analysis and selector generation
-- **Smart Translation**: Language detection with caching
-- **JSON Processing**: Intelligent data transformation
-- **Type Generation**: Pydantic and TypeScript schema creation
-- **Cost Control**: Real-time budget tracking and limits
-- **Type Safety**: 100% Pydantic v2 compliance
-
-## Quick Start
-
-```python
-from unrealon_llm import UnrealOnLLM, LLMConfig
-
-# Initialize with API keys
-config = LLMConfig(
-    openrouter_api_key="sk-or-v1-...",
-    daily_cost_limit_usd=10.0
-)
-
-llm = UnrealOnLLM(config)
-
-# Analyze HTML and generate selectors
-result = await llm.process_html_to_types(
-    html_content="<div class='product'>...</div>",
-    target_elements=["title", "price"],
-    target_language="en"
-)
-```
-
-## Installation
-
-```bash
-pip install unrealon-llm
-```
-
-## Documentation
-
-See the full documentation in the `@docs` directory.

unrealon_llm/__init__.py

@@ -1,26 +0,0 @@
-"""
-🤖 UnrealOn LLM v1.0 - Large Language Model Integration
-
-Advanced LLM integration tools for AI-powered parsing and data processing.
-Service-based architecture following KISS principles.
-"""
-
-# Import everything from src
-from .src import *
-
-# Description
-__description__ = "Large Language Model integration tools for UnrealOn SDK"
-
-
-# Import from centralized config
-from unrealon.sdk_config import (
-    VERSION as __version__,
-    AUTHOR as __author__,
-    AUTHOR_EMAIL as __email__,
-    LICENSE as __license__,
-    PROJECT_URL as __url__,
-    VERSION_INFO,
-    PROJECT_INFO,
-    get_version,
-    is_debug_mode,
-)

unrealon_llm/pyproject.toml

@@ -1,154 +0,0 @@
-[tool.poetry]
-name = "unrealon-llm"
-version = "2.0.0"
-description = "UnrealOn LLM - Modular AI-Powered Processing Platform for HTML analysis, translation, and type conversion"
-authors = ["UnrealOn Team <dev@unrealon.com>"]
-license = "MIT"
-readme = "README.md"
-homepage = "https://github.com/unrealon/unrealon-llm"
-repository = "https://github.com/unrealon/unrealon-llm"
-documentation = "https://docs.unrealon.com/llm"
-keywords = ["llm", "ai", "html-analysis", "translation", "openrouter", "claude", "gpt"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Internet :: WWW/HTTP :: Browsers",
-    "Topic :: Text Processing :: Linguistic",
-    "Topic :: Scientific/Engineering :: Artificial Intelligence",
-]
-packages = [{include = "*", from = "src"}]
-
-[tool.poetry.dependencies]
-python = "^3.9"
-pydantic = "^2.0.0"
-aiohttp = "^3.8.0"
-beautifulsoup4 = "^4.12.0"
-openai = "^1.0.0"
-tiktoken = "^0.9.0"
-fast-langdetect = "^0.3.2"
-langid = "^1.1.6"
-langdetect = "^1.0.9"
-cachetools = "^5.3.0"
-python-dotenv = "^1.0.0"
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^7.4.0"
-pytest-asyncio = "^0.21.0"
-pytest-cov = "^4.1.0"
-pytest-mock = "^3.11.0"
-aioresponses = "^0.7.4"
-black = "^23.7.0"
-isort = "^5.12.0"
-mypy = "^1.5.0"
-flake8 = "^6.0.0"
-pre-commit = "^3.3.0"
-
-[tool.poetry.group.test.dependencies]
-pytest-benchmark = "^4.0.0"
-pytest-xdist = "^3.3.0"
-pytest-html = "^3.2.0"
-factory-boy = "^3.3.0"
-freezegun = "^1.2.0"
-
-[tool.poetry.group.docs.dependencies]
-mkdocs = "^1.5.0"
-mkdocs-material = "^9.1.0"
-mkdocs-mermaid2-plugin = "^1.1.0"
-
-[tool.poetry.scripts]
-unrealon-llm = "unrealon_llm.cli.main:main"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.pytest.ini_options]
-minversion = "7.0"
-addopts = "-ra -q --strict-markers --disable-warnings"
-testpaths = ["tests"]
-markers = [
-    "unit: Unit tests",
-    "integration: Integration tests", 
-    "performance: Performance tests",
-    "real_api: Tests that use real APIs (cost money)",
-    "mock_only: Tests that only use mocks",
-    "ai_validation: AI output quality tests",
-    "cost_controlled: Tests with cost limits",
-]
-asyncio_mode = "auto"
-
-[tool.coverage.run]
-source = ["unrealon_llm"]
-omit = [
-    "*/tests/*",
-    "*/test_*",
-    "*/__pycache__/*",
-    "*/migrations/*",
-]
-
-[tool.coverage.report]
-exclude_lines = [
-    "pragma: no cover",
-    "def __repr__",
-    "if self.debug:",
-    "if settings.DEBUG",
-    "raise AssertionError",
-    "raise NotImplementedError",
-    "if 0:",
-    "if __name__ == .__main__.:",
-    "class .*\\bProtocol\\):",
-    "@(abc\\.)?abstractmethod",
-]
-
-[tool.black]
-line-length = 88
-target-version = ['py38', 'py39', 'py310', 'py311']
-include = '\.pyi?$'
-extend-exclude = '''
-/(
-  \.eggs
-  | \.git
-  | \.hg
-  | \.mypy_cache
-  | \.tox
-  | \.venv
-  | _build
-  | buck-out
-  | build
-  | dist
-)/
-'''
-
-[tool.isort]
-profile = "black"
-multi_line_output = 3
-line_length = 88
-known_first_party = ["unrealon_llm"]
-
-[tool.mypy]
-python_version = "3.8"
-check_untyped_defs = true
-disallow_untyped_defs = true
-disallow_incomplete_defs = true
-disallow_untyped_decorators = true
-no_implicit_optional = true
-warn_return_any = true
-warn_unused_ignores = true
-warn_redundant_casts = true
-strict_equality = true
-
-[[tool.mypy.overrides]]
-module = [
-    "langdetect.*",
-    "tiktoken.*",
-    "beautifulsoup4.*", 
-    "bs4.*",
-]
-ignore_missing_imports = true