fishertools 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

fishertools/learn/repl/models.py

@@ -0,0 +1,121 @@
+"""
+Data models for the Knowledge Engine REPL.
+
+This module defines the core data structures used throughout the REPL system.
+"""
+
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from typing import List, Dict, Optional, Any
+
+
+@dataclass
+class ExampleDisplay:
+    """Represents a code example for display in the REPL."""
+    
+    number: int
+    description: str
+    code: str
+    expected_output: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ExampleDisplay":
+        """Create from dictionary."""
+        return cls(**data)
+
+
+@dataclass
+class TopicDisplay:
+    """Represents a topic with all its information for display."""
+    
+    name: str
+    category: str
+    difficulty: str
+    description: str
+    examples: List[ExampleDisplay] = field(default_factory=list)
+    common_mistakes: List[str] = field(default_factory=list)
+    related_topics: List[str] = field(default_factory=list)
+    tips: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        data = asdict(self)
+        data["examples"] = [ex.to_dict() for ex in self.examples]
+        return data
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TopicDisplay":
+        """Create from dictionary."""
+        examples = [ExampleDisplay.from_dict(ex) for ex in data.get("examples", [])]
+        return cls(
+            name=data["name"],
+            category=data["category"],
+            difficulty=data["difficulty"],
+            description=data["description"],
+            examples=examples,
+            common_mistakes=data.get("common_mistakes", []),
+            related_topics=data.get("related_topics", []),
+            tips=data.get("tips", []),
+        )
+
+
+@dataclass
+class ProgressStats:
+    """Statistics about learning progress."""
+    
+    total_topics: int
+    viewed_topics: int
+    total_examples: int
+    executed_examples: int
+    categories_explored: Dict[str, int] = field(default_factory=dict)
+    difficulty_distribution: Dict[str, int] = field(default_factory=dict)
+    session_duration: float = 0.0
+    last_viewed_topic: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ProgressStats":
+        """Create from dictionary."""
+        return cls(**data)
+
+
+@dataclass
+class SessionState:
+    """Represents the state of a REPL session."""
+    
+    current_topic: Optional[str] = None
+    viewed_topics: List[str] = field(default_factory=list)
+    executed_examples: Dict[str, List[int]] = field(default_factory=dict)
+    session_history: List[str] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+    last_updated: datetime = field(default_factory=datetime.now)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "current_topic": self.current_topic,
+            "viewed_topics": self.viewed_topics,
+            "executed_examples": self.executed_examples,
+            "session_history": self.session_history,
+            "created_at": self.created_at.isoformat(),
+            "last_updated": self.last_updated.isoformat(),
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SessionState":
+        """Create from dictionary."""
+        return cls(
+            current_topic=data.get("current_topic"),
+            viewed_topics=data.get("viewed_topics", []),
+            executed_examples=data.get("executed_examples", {}),
+            session_history=data.get("session_history", []),
+            created_at=datetime.fromisoformat(data["created_at"]) if "created_at" in data else datetime.now(),
+            last_updated=datetime.fromisoformat(data["last_updated"]) if "last_updated" in data else datetime.now(),
+        )

fishertools/learn/repl/session_manager.py

@@ -0,0 +1,284 @@
+"""
+Session manager for tracking learning progress and session state.
+
+This module handles tracking viewed topics, executed examples, and persisting
+session state to disk for resuming learning sessions.
+"""
+
+import json
+import os
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+
+from fishertools.learn.repl.models import SessionState, ProgressStats
+
+
+class SessionManager:
+    """
+    Manages learning progress and session state for the REPL.
+    
+    Tracks:
+    - Viewed topics
+    - Executed examples
+    - Session history
+    - Learning statistics
+    
+    Persists state to JSON files for resuming sessions.
+    
+    Example:
+        >>> manager = SessionManager()
+        >>> manager.mark_topic_viewed("Lists")
+        >>> manager.mark_example_executed("Lists", 1)
+        >>> stats = manager.get_progress()
+        >>> manager.save_session()
+    """
+    
+    DEFAULT_SESSION_FILE = ".repl_session.json"
+    DEFAULT_PROGRESS_FILE = ".repl_progress.json"
+    
+    def __init__(self, storage_path: Optional[str] = None):
+        """
+        Initialize the session manager.
+        
+        Args:
+            storage_path: Optional path to store session files. 
+                         Defaults to user's home directory.
+        """
+        if storage_path is None:
+            storage_path = str(Path.home())
+        
+        self.storage_path = Path(storage_path)
+        self.session_file = self.storage_path / self.DEFAULT_SESSION_FILE
+        self.progress_file = self.storage_path / self.DEFAULT_PROGRESS_FILE
+        
+        # Initialize session state
+        self.state = SessionState()
+        self.session_start_time = datetime.now()
+        
+        # Load existing session if available
+        self.load_session()
+    
+    def mark_topic_viewed(self, topic_name: str) -> None:
+        """
+        Mark a topic as viewed.
+        
+        Args:
+            topic_name: Name of the topic to mark as viewed
+        """
+        if topic_name not in self.state.viewed_topics:
+            self.state.viewed_topics.append(topic_name)
+        
+        # Add to session history
+        if not self.state.session_history or self.state.session_history[-1] != topic_name:
+            self.state.session_history.append(topic_name)
+        
+        self.state.last_updated = datetime.now()
+    
+    def mark_example_executed(self, topic_name: str, example_num: int) -> None:
+        """
+        Mark an example as executed.
+        
+        Args:
+            topic_name: Name of the topic
+            example_num: Number of the example
+        """
+        if topic_name not in self.state.executed_examples:
+            self.state.executed_examples[topic_name] = []
+        
+        if example_num not in self.state.executed_examples[topic_name]:
+            self.state.executed_examples[topic_name].append(example_num)
+        
+        self.state.last_updated = datetime.now()
+    
+    def get_progress(self) -> ProgressStats:
+        """
+        Get current learning progress statistics.
+        
+        Returns:
+            ProgressStats object with current statistics
+        """
+        # Calculate statistics
+        total_topics = len(self.state.viewed_topics)
+        viewed_topics = len(self.state.viewed_topics)
+        
+        total_examples = sum(len(examples) for examples in self.state.executed_examples.values())
+        executed_examples = total_examples
+        
+        # Calculate session duration
+        session_duration = (datetime.now() - self.session_start_time).total_seconds()
+        
+        return ProgressStats(
+            total_topics=total_topics,
+            viewed_topics=viewed_topics,
+            total_examples=total_examples,
+            executed_examples=executed_examples,
+            categories_explored={},
+            difficulty_distribution={},
+            session_duration=session_duration,
+            last_viewed_topic=self.state.current_topic,
+        )
+    
+    def get_viewed_topics(self) -> List[str]:
+        """
+        Get list of viewed topics.
+        
+        Returns:
+            List of topic names that have been viewed
+        """
+        return self.state.viewed_topics.copy()
+    
+    def get_executed_examples(self) -> Dict[str, List[int]]:
+        """
+        Get dictionary of executed examples by topic.
+        
+        Returns:
+            Dictionary mapping topic names to lists of executed example numbers
+        """
+        return {k: v.copy() for k, v in self.state.executed_examples.items()}
+    
+    def set_current_topic(self, topic_name: str) -> None:
+        """
+        Set the current topic.
+        
+        Args:
+            topic_name: Name of the current topic
+        """
+        self.state.current_topic = topic_name
+        self.state.last_updated = datetime.now()
+    
+    def get_current_topic(self) -> Optional[str]:
+        """
+        Get the current topic.
+        
+        Returns:
+            Name of the current topic or None if not set
+        """
+        return self.state.current_topic
+    
+    def get_session_history(self) -> List[str]:
+        """
+        Get history of viewed topics in current session.
+        
+        Returns:
+            List of topic names in order they were viewed
+        """
+        return self.state.session_history.copy()
+    
+    def save_session(self) -> bool:
+        """
+        Save session state to persistent storage.
+        
+        Returns:
+            True if save was successful, False otherwise
+        """
+        try:
+            # Ensure storage directory exists
+            self.storage_path.mkdir(parents=True, exist_ok=True)
+            
+            # Save session state
+            session_data = self.state.to_dict()
+            with open(self.session_file, 'w', encoding='utf-8') as f:
+                json.dump(session_data, f, indent=2, default=str)
+            
+            return True
+        except Exception as e:
+            print(f"Warning: Could not save session: {e}")
+            return False
+    
+    def load_session(self) -> bool:
+        """
+        Load session state from persistent storage.
+        
+        Returns:
+            True if load was successful, False otherwise
+        """
+        try:
+            if not self.session_file.exists():
+                return False
+            
+            with open(self.session_file, 'r', encoding='utf-8') as f:
+                session_data = json.load(f)
+            
+            self.state = SessionState.from_dict(session_data)
+            self.session_start_time = datetime.now()
+            return True
+        except Exception as e:
+            print(f"Warning: Could not load session: {e}")
+            return False
+    
+    def reset_progress(self) -> None:
+        """
+        Reset all learning progress.
+        
+        Clears viewed topics, executed examples, and session history.
+        """
+        self.state = SessionState()
+        self.session_start_time = datetime.now()
+    
+    def clear_session_history(self) -> None:
+        """
+        Clear the session history.
+        
+        Keeps viewed topics and executed examples but clears the history.
+        """
+        self.state.session_history = []
+        self.state.last_updated = datetime.now()
+    
+    def get_session_info(self) -> Dict[str, Any]:
+        """
+        Get information about the current session.
+        
+        Returns:
+            Dictionary with session information
+        """
+        session_duration = (datetime.now() - self.session_start_time).total_seconds()
+        
+        return {
+            "current_topic": self.state.current_topic,
+            "topics_viewed": len(self.state.viewed_topics),
+            "examples_executed": sum(len(ex) for ex in self.state.executed_examples.values()),
+            "session_duration_seconds": session_duration,
+            "session_history_length": len(self.state.session_history),
+            "created_at": self.state.created_at.isoformat(),
+            "last_updated": self.state.last_updated.isoformat(),
+        }
+    
+    def is_topic_viewed(self, topic_name: str) -> bool:
+        """
+        Check if a topic has been viewed.
+        
+        Args:
+            topic_name: Name of the topic
+        
+        Returns:
+            True if topic has been viewed, False otherwise
+        """
+        return topic_name in self.state.viewed_topics
+    
+    def is_example_executed(self, topic_name: str, example_num: int) -> bool:
+        """
+        Check if an example has been executed.
+        
+        Args:
+            topic_name: Name of the topic
+            example_num: Number of the example
+        
+        Returns:
+            True if example has been executed, False otherwise
+        """
+        if topic_name not in self.state.executed_examples:
+            return False
+        return example_num in self.state.executed_examples[topic_name]
+    
+    def get_examples_executed_for_topic(self, topic_name: str) -> List[int]:
+        """
+        Get list of executed examples for a topic.
+        
+        Args:
+            topic_name: Name of the topic
+        
+        Returns:
+            List of executed example numbers
+        """
+        return self.state.executed_examples.get(topic_name, []).copy()

fishertools/learn/repl/test_code_sandbox.py

@@ -0,0 +1,261 @@
+"""
+Unit tests for the CodeSandbox class.
+"""
+
+import pytest
+from fishertools.learn.repl.code_sandbox import CodeSandbox
+
+
+class TestCodeSandboxBasic:
+    """Test basic code execution in the sandbox."""
+    
+    def test_execute_simple_print(self):
+        """Test executing simple print statement."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print('Hello')")
+        assert success is True
+        assert "Hello" in output
+    
+    def test_execute_arithmetic(self):
+        """Test executing arithmetic operations."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print(2 + 2)")
+        assert success is True
+        assert "4" in output
+    
+    def test_execute_variable_assignment(self):
+        """Test executing variable assignment."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("x = 5\nprint(x * 2)")
+        assert success is True
+        assert "10" in output
+    
+    def test_execute_list_operations(self):
+        """Test executing list operations."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("lst = [1, 2, 3]\nprint(sum(lst))")
+        assert success is True
+        assert "6" in output
+    
+    def test_execute_loop(self):
+        """Test executing for loop."""
+        sandbox = CodeSandbox()
+        code = """
+for i in range(3):
+    print(i)
+"""
+        success, output = sandbox.execute(code)
+        assert success is True
+        assert "0" in output
+        assert "1" in output
+        assert "2" in output
+    
+    def test_execute_function_definition(self):
+        """Test executing function definition."""
+        sandbox = CodeSandbox()
+        code = """
+def add(a, b):
+    return a + b
+
+print(add(3, 4))
+"""
+        success, output = sandbox.execute(code)
+        assert success is True
+        assert "7" in output
+
+
+class TestCodeSandboxErrors:
+    """Test error handling in the sandbox."""
+    
+    def test_syntax_error(self):
+        """Test handling of syntax errors."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print('unclosed")
+        assert success is False
+        assert "Syntax Error" in output
+    
+    def test_runtime_error(self):
+        """Test handling of runtime errors."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print(1 / 0)")
+        assert success is False
+        assert "ZeroDivisionError" in output
+    
+    def test_name_error(self):
+        """Test handling of undefined variables."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print(undefined_var)")
+        assert success is False
+        assert "NameError" in output
+    
+    def test_empty_code(self):
+        """Test handling of empty code."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("")
+        assert success is False
+        assert "empty" in output.lower()
+    
+    def test_whitespace_only_code(self):
+        """Test handling of whitespace-only code."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("   \n  \n  ")
+        assert success is False
+
+
+class TestCodeSandboxRestrictions:
+    """Test that dangerous operations are blocked."""
+    
+    def test_block_import(self):
+        """Test that imports are blocked."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("import os")
+        assert success is False
+        assert "import" in output.lower() or "not allowed" in output.lower()
+    
+    def test_block_from_import(self):
+        """Test that from imports are blocked."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("from os import path")
+        assert success is False
+        assert "import" in output.lower() or "not allowed" in output.lower()
+    
+    def test_block_open_function(self):
+        """Test that open() is blocked."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("open('file.txt')")
+        assert success is False
+        assert "not allowed" in output.lower() or "file" in output.lower()
+    
+    def test_block_exec(self):
+        """Test that exec() is blocked."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("exec('print(1)')")
+        assert success is False
+        assert "not allowed" in output.lower()
+    
+    def test_block_eval(self):
+        """Test that eval() is blocked."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("eval('1+1')")
+        assert success is False
+        assert "not allowed" in output.lower()
+    
+    def test_block_globals(self):
+        """Test that globals() is blocked."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("globals()")
+        assert success is False
+        assert "not allowed" in output.lower()
+
+
+class TestCodeSandboxMath:
+    """Test math operations in the sandbox."""
+    
+    def test_math_module_available(self):
+        """Test that math module is available."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("import math\nprint(math.pi)")
+        # Math module should be available through restricted globals
+        # But import should be blocked
+        assert success is False
+    
+    def test_builtin_math_functions(self):
+        """Test built-in math functions."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print(abs(-5))")
+        assert success is True
+        assert "5" in output
+    
+    def test_pow_function(self):
+        """Test pow function."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print(pow(2, 3))")
+        assert success is True
+        assert "8" in output
+    
+    def test_round_function(self):
+        """Test round function."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print(round(3.7))")
+        assert success is True
+        assert "4" in output
+
+
+class TestCodeSandboxUtilityMethods:
+    """Test utility methods of CodeSandbox."""
+    
+    def test_get_available_builtins(self):
+        """Test getting list of available built-ins."""
+        sandbox = CodeSandbox()
+        builtins = sandbox.get_available_builtins()
+        assert isinstance(builtins, list)
+        assert "print" in builtins
+        assert "len" in builtins
+        assert "sum" in builtins
+    
+    def test_get_blocked_builtins(self):
+        """Test getting list of blocked built-ins."""
+        sandbox = CodeSandbox()
+        blocked = sandbox.get_blocked_builtins()
+        assert isinstance(blocked, list)
+        assert "open" in blocked
+        assert "exec" in blocked
+        assert "eval" in blocked
+    
+    def test_get_blocked_modules(self):
+        """Test getting list of blocked modules."""
+        sandbox = CodeSandbox()
+        blocked = sandbox.get_blocked_modules()
+        assert isinstance(blocked, list)
+        assert "os" in blocked
+        assert "sys" in blocked
+        assert "subprocess" in blocked
+
+
+class TestCodeSandboxEdgeCases:
+    """Test edge cases in code execution."""
+    
+    def test_multiline_code(self):
+        """Test executing multiline code."""
+        sandbox = CodeSandbox()
+        code = """
+x = 10
+y = 20
+z = x + y
+print(z)
+"""
+        success, output = sandbox.execute(code)
+        assert success is True
+        assert "30" in output
+    
+    def test_nested_loops(self):
+        """Test executing nested loops."""
+        sandbox = CodeSandbox()
+        code = """
+for i in range(2):
+    for j in range(2):
+        print(f"{i},{j}")
+"""
+        success, output = sandbox.execute(code)
+        assert success is True
+        assert "0,0" in output
+    
+    def test_list_comprehension(self):
+        """Test list comprehension."""
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute("print([x*2 for x in range(3)])")
+        assert success is True
+        assert "0" in output
+        assert "2" in output
+        assert "4" in output
+    
+    def test_dictionary_operations(self):
+        """Test dictionary operations."""
+        sandbox = CodeSandbox()
+        code = """
+d = {'a': 1, 'b': 2}
+print(d['a'])
+"""
+        success, output = sandbox.execute(code)
+        assert success is True
+        assert "1" in output