fishertools 0.2.1__py3-none-any.whl

fishertools/__init__.py

@@ -0,0 +1,82 @@
+"""
+Fishertools - инструменты, которые делают Python удобнее и безопаснее для новичков
+
+Основная функция:
+    explain_error() - объясняет ошибки Python в понятных словах
+
+Модули:
+    errors - система объяснения ошибок
+    safe - безопасные утилиты для новичков
+    learn - обучающие инструменты
+    legacy - функции для обратной совместимости
+"""
+
+__version__ = "0.2.1"
+__author__ = "f1sherFM"
+
+# Primary API - main interface for users
+from .errors import explain_error
+
+# Exception classes for error handling
+from .errors import (
+    FishertoolsError, ExplanationError, FormattingError, 
+    ConfigurationError, PatternError, SafeUtilityError
+)
+
+# Safe utilities - commonly used beginner-friendly functions
+from .safe import (
+    safe_get, safe_divide, safe_max, safe_min, safe_sum,
+    safe_read_file, safe_write_file, safe_file_exists, 
+    safe_get_file_size, safe_list_files
+)
+
+# Learning tools - educational functions
+from .learn import (
+    generate_example, show_best_practice, 
+    list_available_concepts, list_available_topics
+)
+
+# Legacy imports for backward compatibility
+from . import utils
+from . import decorators  
+from . import helpers
+
+# Module imports for advanced users who want to access specific modules
+from . import errors
+from . import safe
+from . import learn
+from . import legacy
+
+# New enhancement modules (fishertools-enhancements)
+from . import learning
+from . import documentation
+from . import examples
+from . import config
+from . import integration
+
+__all__ = [
+    # Primary API - the main function users should import
+    "explain_error",
+    
+    # Exception classes for error handling
+    "FishertoolsError", "ExplanationError", "FormattingError", 
+    "ConfigurationError", "PatternError", "SafeUtilityError",
+    
+    # Safe utilities - direct access to commonly used functions
+    "safe_get", "safe_divide", "safe_max", "safe_min", "safe_sum",
+    "safe_read_file", "safe_write_file", "safe_file_exists", 
+    "safe_get_file_size", "safe_list_files",
+    
+    # Learning tools - direct access to educational functions
+    "generate_example", "show_best_practice", 
+    "list_available_concepts", "list_available_topics",
+    
+    # Legacy modules for backward compatibility
+    "utils", "decorators", "helpers",
+    
+    # New modules for advanced usage
+    "errors", "safe", "learn", "legacy",
+    
+    # Enhancement modules (fishertools-enhancements)
+    "learning", "documentation", "examples", "config", "integration"
+]

fishertools/config/__init__.py

@@ -0,0 +1,24 @@
+"""
+Configuration Management Module
+
+Handles learning system configuration through various file formats
+with validation and error recovery.
+"""
+
+from .manager import ConfigurationManager
+from .parser import ConfigurationParser
+from .models import (
+    LearningConfig,
+    ValidationResult,
+    RecoveryAction,
+    ConfigError
+)
+
+__all__ = [
+    "ConfigurationManager",
+    "ConfigurationParser",
+    "LearningConfig",
+    "ValidationResult",
+    "RecoveryAction", 
+    "ConfigError"
+]

fishertools/config/manager.py

@@ -0,0 +1,247 @@
+"""
+Configuration manager for the learning system.
+"""
+
+from typing import Optional, Dict, Any
+import json
+import os
+from dataclasses import asdict
+from .models import LearningConfig, ValidationResult, RecoveryAction, ConfigError
+from .parser import ConfigurationParser
+
+
+class ConfigurationManager:
+    """
+    Manages learning system configuration through various file formats.
+    
+    Handles loading, saving, validation, and error recovery for
+    configuration files in JSON, YAML, and TOML formats.
+    """
+    
+    def __init__(self, default_config_path: Optional[str] = None):
+        """
+        Initialize the configuration manager.
+        
+        Args:
+            default_config_path: Optional path to default configuration file
+        """
+        self.default_config_path = default_config_path or self._get_default_config_path()
+        self.parser = ConfigurationParser()
+        self._current_config: Optional[LearningConfig] = None
+    
+    def _get_default_config_path(self) -> str:
+        """Get the path to the default configuration file."""
+        current_dir = os.path.dirname(__file__)
+        return os.path.join(current_dir, 'default_config.json')
+    
+    def load_config(self, config_path: str) -> LearningConfig:
+        """
+        Load configuration from a file.
+        
+        Args:
+            config_path: Path to the configuration file
+            
+        Returns:
+            LearningConfig: Loaded configuration
+            
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+            ValueError: If config format is invalid
+        """
+        try:
+            # Parse the configuration file
+            config_data = self.parser.parse_file(config_path)
+            
+            # Validate the configuration
+            validation_result = self.parser.validate_structure(config_data)
+            
+            if not validation_result.is_valid:
+                error_messages = [error.message for error in validation_result.errors]
+                raise ValueError(f"Configuration validation failed: {'; '.join(error_messages)}")
+            
+            # Create LearningConfig object with defaults for missing fields
+            default_config = self.get_default_config()
+            merged_config = self.merge_configs(default_config, config_data)
+            
+            self._current_config = merged_config
+            return merged_config
+            
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+        except Exception as e:
+            raise ValueError(f"Failed to load configuration: {e}")
+    
+    def save_config(self, config: LearningConfig, config_path: str) -> None:
+        """
+        Save configuration to a file.
+        
+        Args:
+            config: Configuration to save
+            config_path: Path where to save the configuration
+            
+        Raises:
+            IOError: If file cannot be written
+        """
+        try:
+            # Determine format based on file extension
+            format_type = self.parser.detect_format(config_path)
+            
+            # Format the configuration
+            if format_type.value == 'json':
+                content = self.parser.format_to_json(config)
+            elif format_type.value == 'yaml':
+                content = self.parser.format_to_yaml(config)
+            else:
+                raise ValueError(f"Unsupported format for saving: {format_type}")
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            
+            # Write the file
+            with open(config_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+                
+        except Exception as e:
+            raise IOError(f"Failed to save configuration to {config_path}: {e}")
+    
+    def validate_config(self, config: LearningConfig) -> ValidationResult:
+        """
+        Validate a configuration object.
+        
+        Args:
+            config: Configuration to validate
+            
+        Returns:
+            ValidationResult: Validation result with errors/warnings
+        """
+        # Convert config to dict for validation
+        config_dict = asdict(config)
+        return self.parser.validate_structure(config_dict)
+    
+    def apply_config(self, config: LearningConfig) -> None:
+        """
+        Apply configuration to the learning system.
+        
+        Args:
+            config: Configuration to apply
+        """
+        # Validate the configuration first
+        validation_result = self.validate_config(config)
+        
+        if not validation_result.is_valid:
+            error_messages = [error.message for error in validation_result.errors]
+            raise ValueError(f"Cannot apply invalid configuration: {'; '.join(error_messages)}")
+        
+        # Store as current configuration
+        self._current_config = config
+        
+        # Here we would apply the configuration to various system components
+        # For now, we just store it as the current configuration
+    
+    def get_default_config(self) -> LearningConfig:
+        """
+        Get the default configuration.
+        
+        Returns:
+            LearningConfig: Default configuration
+        """
+        try:
+            if os.path.exists(self.default_config_path):
+                config_data = self.parser.parse_file(self.default_config_path)
+                return self._dict_to_config(config_data)
+            else:
+                # Return hardcoded defaults if file doesn't exist
+                return LearningConfig()
+        except Exception:
+            # Return hardcoded defaults if parsing fails
+            return LearningConfig()
+    
+    def merge_configs(self, base_config: LearningConfig, override_config: Dict[str, Any]) -> LearningConfig:
+        """
+        Merge configuration with overrides.
+        
+        Args:
+            base_config: Base configuration
+            override_config: Configuration overrides
+            
+        Returns:
+            LearningConfig: Merged configuration
+        """
+        # Convert base config to dict
+        base_dict = asdict(base_config)
+        
+        # Update with overrides
+        base_dict.update(override_config)
+        
+        # Convert back to LearningConfig
+        return self._dict_to_config(base_dict)
+    
+    def _dict_to_config(self, config_dict: Dict[str, Any]) -> LearningConfig:
+        """
+        Convert dictionary to LearningConfig object.
+        
+        Args:
+            config_dict: Configuration dictionary
+            
+        Returns:
+            LearningConfig: Configuration object
+        """
+        # Filter out unknown fields and create LearningConfig
+        valid_fields = {
+            field.name for field in LearningConfig.__dataclass_fields__.values()
+        }
+        
+        filtered_dict = {
+            key: value for key, value in config_dict.items()
+            if key in valid_fields
+        }
+        
+        return LearningConfig(**filtered_dict)
+    
+    def get_current_config(self) -> Optional[LearningConfig]:
+        """
+        Get the currently loaded configuration.
+        
+        Returns:
+            Optional[LearningConfig]: Current configuration or None if not loaded
+        """
+        return self._current_config
+    
+    def handle_config_error(self, error: ConfigError) -> RecoveryAction:
+        """
+        Handle configuration errors with appropriate recovery actions.
+        
+        Args:
+            error: Configuration error to handle
+            
+        Returns:
+            RecoveryAction: Recommended recovery action
+        """
+        from ..errors.recovery import get_recovery_manager, ErrorContext, ErrorSeverity
+        
+        recovery_manager = get_recovery_manager()
+        
+        # Determine error severity based on error type
+        if isinstance(error, FileNotFoundError):
+            severity = ErrorSeverity.MEDIUM
+            error_type = "config_file_missing"
+        elif "validation" in str(error).lower():
+            severity = ErrorSeverity.MEDIUM
+            error_type = "config_validation_error"
+        elif "parse" in str(error).lower() or "syntax" in str(error).lower():
+            severity = ErrorSeverity.HIGH
+            error_type = "config_parse_error"
+        else:
+            severity = ErrorSeverity.MEDIUM
+            error_type = "config_general_error"
+        
+        error_context = ErrorContext(
+            component="configuration",
+            operation="load_config",
+            error_type=error_type,
+            error_message=str(error),
+            severity=severity,
+            metadata={"config_path": getattr(error, 'config_path', 'unknown')}
+        )
+        
+        return recovery_manager.handle_error(error_context)

fishertools/config/models.py

@@ -0,0 +1,96 @@
+"""
+Data models for the Configuration Management module.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any, Literal
+from enum import Enum
+
+
+class ConfigFormat(Enum):
+    """Supported configuration file formats."""
+    JSON = "json"
+    YAML = "yaml"
+    TOML = "toml"
+
+
+class ErrorSeverity(Enum):
+    """Severity levels for configuration errors."""
+    WARNING = "warning"
+    ERROR = "error"
+    CRITICAL = "critical"
+
+
+class RecoveryStrategy(Enum):
+    """Strategies for error recovery."""
+    USE_DEFAULTS = "use_defaults"
+    PROMPT_USER = "prompt_user"
+    FAIL_GRACEFULLY = "fail_gracefully"
+    RETRY = "retry"
+
+
+@dataclass
+class ConfigError:
+    """Configuration error information."""
+    message: str
+    field_path: str
+    severity: ErrorSeverity
+    suggested_fix: Optional[str] = None
+    line_number: Optional[int] = None
+
+
+@dataclass
+class ValidationResult:
+    """Result of configuration validation."""
+    is_valid: bool
+    errors: List[ConfigError] = None
+    warnings: List[ConfigError] = None
+    
+    def __post_init__(self):
+        if self.errors is None:
+            self.errors = []
+        if self.warnings is None:
+            self.warnings = []
+
+
+@dataclass
+class RecoveryAction:
+    """Action to take for error recovery."""
+    strategy: RecoveryStrategy
+    message: str
+    fallback_config: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class LearningConfig:
+    """Configuration for the learning system."""
+    # Basic settings
+    default_level: Literal["beginner", "intermediate", "advanced"] = "beginner"
+    explanation_verbosity: Literal["brief", "detailed", "comprehensive"] = "detailed"
+    
+    # Visual settings
+    visual_aids_enabled: bool = True
+    diagram_style: str = "modern"
+    color_scheme: str = "default"
+    
+    # Progress and tracking
+    progress_tracking_enabled: bool = True
+    save_progress_locally: bool = True
+    
+    # Content and examples
+    suggested_topics_count: int = 3
+    max_examples_per_topic: int = 5
+    exercise_difficulty_progression: List[str] = None
+    
+    # Integration
+    readthedocs_project: Optional[str] = None
+    sphinx_theme: str = "sphinx_rtd_theme"
+    
+    # Advanced settings
+    enable_interactive_sessions: bool = True
+    session_timeout_minutes: int = 30
+    max_hint_count: int = 3
+    
+    def __post_init__(self):
+        if self.exercise_difficulty_progression is None:
+            self.exercise_difficulty_progression = ["beginner", "intermediate", "advanced"]