edsl 0.1.39.dev2__py3-none-any.whl → 0.1.39.dev3__py3-none-any.whl

edsl/scenarios/DocxScenario.py

@@ -1,16 +0,0 @@
-class DocxScenario:
-    def __init__(self, docx_path: str):
-        from docx import Document
-
-        self.doc = Document(docx_path)
-        self.docx_path = docx_path
-
-    def get_scenario_dict(self) -> dict:
-        # Extract all text
-        full_text = []
-        for para in self.doc.paragraphs:
-            full_text.append(para.text)
-
-        # Join the text from all paragraphs
-        text = "\n".join(full_text)
-        return {"file_path": self.docx_path, "text": text}

edsl/scenarios/PdfExtractor.py

@@ -1,40 +0,0 @@
-import os
-
-
-class PdfExtractor:
-    def __init__(self, pdf_path: str, parent_object: object):
-        self.pdf_path = pdf_path
-        self.constructor = parent_object.__class__
-
-    def get_object(self) -> object:
-        return self.constructor(self._get_pdf_dict())
-
-    def _get_pdf_dict(self) -> dict:
-        # Ensure the file exists
-        import fitz
-
-        if not os.path.exists(self.pdf_path):
-            raise FileNotFoundError(f"The file {self.pdf_path} does not exist.")
-
-        # Open the PDF file
-        document = fitz.open(self.pdf_path)
-
-        # Get the filename from the path
-        filename = os.path.basename(self.pdf_path)
-
-        # Iterate through each page and extract text
-        text = ""
-        for page_num in range(len(document)):
-            page = document.load_page(page_num)
-            blocks = page.get_text("blocks")  # Extract text blocks
-
-            # Sort blocks by their vertical position (y0) to maintain reading order
-            blocks.sort(key=lambda b: (b[1], b[0]))  # Sort by y0 first, then x0
-
-            # Combine the text blocks in order
-            for block in blocks:
-                text += block[4] + "\n"
-
-        # Create a dictionary for the combined text
-        page_info = {"filename": filename, "text": text}
-        return page_info

edsl/scenarios/ScenarioSelector.py

@@ -1,156 +0,0 @@
-from typing import TYPE_CHECKING
-
-
-class ScenarioSelector:
-    """
-    A class for performing advanced field selection on ScenarioList objects,
-    including support for wildcard patterns.
-
-    Args:
-        scenario_list: The ScenarioList object to perform selections on
-
-    Examples:
-        >>> from edsl import Scenario, ScenarioList
-        >>> scenarios = ScenarioList([Scenario({'test_1': 1, 'test_2': 2, 'other': 3}), Scenario({'test_1': 4, 'test_2': 5, 'other': 6})])
-        >>> selector = ScenarioSelector(scenarios)
-        >>> selector.select('test*')
-        ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
-    """
-
-    def __init__(self, scenario_list: "ScenarioList"):
-        """Initialize with a ScenarioList object."""
-        self.scenario_list = scenario_list
-        self.available_fields = (
-            list(scenario_list.data[0].keys()) if scenario_list.data else []
-        )
-
-    def _match_field_pattern(self, pattern: str, field: str) -> bool:
-        """
-        Checks if a field name matches a pattern with wildcards.
-        Supports '*' as wildcard at start or end of pattern.
-
-        Args:
-            pattern: The pattern to match against, may contain '*' at start or end
-            field: The field name to check
-
-        Examples:
-            >>> from edsl.scenarios import ScenarioList, Scenario
-            >>> selector = ScenarioSelector(ScenarioList([]))
-            >>> selector._match_field_pattern('test*', 'test_field')
-            True
-            >>> selector._match_field_pattern('*field', 'test_field')
-            True
-            >>> selector._match_field_pattern('test', 'test')
-            True
-            >>> selector._match_field_pattern('*test*', 'my_test_field')
-            True
-        """
-        if "*" not in pattern:
-            return pattern == field
-
-        if pattern.startswith("*") and pattern.endswith("*"):
-            return pattern[1:-1] in field
-        elif pattern.startswith("*"):
-            return field.endswith(pattern[1:])
-        elif pattern.endswith("*"):
-            return field.startswith(pattern[:-1])
-        return pattern == field
-
-    def _get_matching_fields(self, patterns: list[str]) -> list[str]:
-        """
-        Gets all fields that match any of the given patterns.
-
-        Args:
-            patterns: List of field patterns, may contain wildcards
-
-        Returns:
-            List of field names that match at least one pattern
-
-        Examples:
-            >>> from edsl import Scenario, ScenarioList
-            >>> scenarios = ScenarioList([
-            ...     Scenario({'test_1': 1, 'test_2': 2, 'other': 3})
-            ... ])
-            >>> selector = ScenarioSelector(scenarios)
-            >>> selector._get_matching_fields(['test*'])
-            ['test_1', 'test_2']
-        """
-        matching_fields = set()
-        for pattern in patterns:
-            matches = [
-                field
-                for field in self.available_fields
-                if self._match_field_pattern(pattern, field)
-            ]
-            matching_fields.update(matches)
-        return sorted(list(matching_fields))
-
-    def select(self, *fields) -> "ScenarioList":
-        """
-        Selects scenarios with only the referenced fields.
-        Supports wildcard patterns using '*' at the start or end of field names.
-
-        Args:
-            *fields: Field names or patterns to select. Patterns may include '*' for wildcards.
-
-        Returns:
-            A new ScenarioList containing only the matched fields.
-
-        Raises:
-            ValueError: If no fields match the given patterns.
-
-        Examples:
-            >>> from edsl import Scenario, ScenarioList
-            >>> scenarios = ScenarioList([
-            ...     Scenario({'test_1': 1, 'test_2': 2, 'other': 3}),
-            ...     Scenario({'test_1': 4, 'test_2': 5, 'other': 6})
-            ... ])
-            >>> selector = ScenarioSelector(scenarios)
-            >>> selector.select('test*')  # Selects all fields starting with 'test'
-            ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
-            >>> selector.select('*_1')  # Selects all fields ending with '_1'
-            ScenarioList([Scenario({'test_1': 1}), Scenario({'test_1': 4})])
-            >>> selector.select('test_1', '*_2')  # Multiple patterns
-            ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
-        """
-        if not self.scenario_list.data:
-            return self.scenario_list.__class__([])
-
-        # Convert single string to list for consistent processing
-        patterns = list(fields)
-
-        # Get all fields that match the patterns
-        fields_to_select = self._get_matching_fields(patterns)
-
-        # If no fields match, raise an informative error
-        if not fields_to_select:
-            raise ValueError(
-                f"No fields matched the given patterns: {patterns}. "
-                f"Available fields are: {self.available_fields}"
-            )
-
-        return self.scenario_list.__class__(
-            [scenario.select(fields_to_select) for scenario in self.scenario_list.data]
-        )
-
-    def get_available_fields(self) -> list[str]:
-        """
-        Returns a list of all available fields in the ScenarioList.
-
-        Returns:
-            List of field names available for selection.
-
-        Examples:
-            >>> from edsl import Scenario, ScenarioList
-            >>> scenarios = ScenarioList([Scenario({'test_1': 1, 'test_2': 2, 'other': 3})])
-            >>> selector = ScenarioSelector(scenarios)
-            >>> selector.get_available_fields()
-            ['other', 'test_1', 'test_2']
-        """
-        return sorted(self.available_fields)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/scenarios/file_methods.py

@@ -1,85 +0,0 @@
-from typing import Optional, Dict, Type
-from abc import ABC, abstractmethod
-import importlib.metadata
-import importlib.util
-
-from edsl.utilities.is_notebook import is_notebook
-
-
-class FileMethods(ABC):
-    _handlers: Dict[str, Type["FileMethods"]] = {}
-
-    def __init__(self, path: Optional[str] = None):
-        self.path = path
-
-    def __init_subclass__(cls) -> None:
-        """Register subclasses automatically when they're defined."""
-        super().__init_subclass__()
-        if hasattr(cls, "suffix"):
-            FileMethods._handlers[cls.suffix] = cls
-
-    @classmethod
-    def get_handler(cls, suffix: str) -> Optional[Type["FileMethods"]]:
-        """Get the appropriate handler class for a given suffix."""
-        # Load plugins if they haven't been loaded yet
-        if not cls._handlers:
-            cls.load_plugins()
-        return cls._handlers.get(suffix.lower())
-
-    @classmethod
-    def load_plugins(cls):
-        """Load all file handler plugins including built-ins and external plugins."""
-
-        from edsl.scenarios import handlers
-
-        # Then load any external plugins
-        try:
-            entries = importlib.metadata.entry_points(group="file_handlers")
-        except TypeError:  # some Python 3.9 bullshit
-            # entries = importlib.metadata.entry_points()
-            entries = []
-
-        for ep in entries:
-            try:
-                handler_class = ep.load()
-                # Registration happens automatically via __init_subclass__
-            except Exception as e:
-                print(f"Failed to load external handler {ep.name}: {e}")
-
-    @classmethod
-    def get_handler_for_path(cls, path: str) -> Optional[Type["FileMethods"]]:
-        """Get the appropriate handler class for a file path."""
-        suffix = path.split(".")[-1].lower() if "." in path else ""
-        return cls.get_handler(suffix)
-
-    @classmethod
-    def create(cls, path: str) -> Optional["FileMethods"]:
-        """Create an appropriate handler instance for the given path."""
-        handler_class = cls.get_handler_for_path(path)
-        if handler_class:
-            return handler_class(path)
-        return None
-
-    @classmethod
-    def supported_file_types(cls):
-        if not cls._handlers:
-            cls.load_plugins()
-        return list(cls._handlers.keys())
-
-    @abstractmethod
-    def view_system(self):
-        ...
-
-    @abstractmethod
-    def view_notebook(self):
-        ...
-
-    def view(self):
-        if is_notebook():
-            self.view_notebook()
-        else:
-            self.view_system()
-
-    @abstractmethod
-    def example(self):
-        ...

edsl/scenarios/handlers/__init__.py

@@ -1,13 +0,0 @@
-from .pdf import PdfMethods
-from .docx import DocxMethods
-from .png import PngMethods
-from .txt import TxtMethods
-from .html import HtmlMethods
-from .md import MarkdownMethods
-from .csv import CsvMethods
-from .json import JsonMethods
-from .sql import SqlMethods
-from .pptx import PptxMethods
-from .latex import LaTeXMethods
-from .py import PyMethods
-from .sqlite import SQLiteMethods

edsl/scenarios/handlers/csv.py

@@ -1,38 +0,0 @@
-import tempfile
-from edsl.scenarios.file_methods import FileMethods
-
-
-class CsvMethods(FileMethods):
-    suffix = "csv"
-
-    def view_system(self):
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening CSV: {e}")
-        else:
-            print("CSV file was not found.")
-
-    def view_notebook(self):
-        import pandas as pd
-        from IPython.display import display
-
-        df = pd.read_csv(self.path)
-        display(df)
-
-    def example(self):
-        import pandas as pd
-
-        df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as f:
-            df.to_csv(f.name, index=False)
-        return f.name

edsl/scenarios/handlers/docx.py

@@ -1,76 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import os
-import tempfile
-
-
-class DocxMethods(FileMethods):
-    suffix = "docx"
-
-    def extract_text(self):
-        from docx import Document
-
-        self.doc = Document(self.path)
-
-        # Extract all text
-        full_text = []
-        for para in self.doc.paragraphs:
-            full_text.append(para.text)
-
-        text = "\n".join(full_text)
-        return text
-
-    def view_system(self):
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening DOCX: {e}")
-        else:
-            print("DOCX file was not found.")
-
-    def view_notebook(self):
-        import mammoth
-        from IPython.display import HTML, display
-
-        with open(self.path, "rb") as docx_file:
-            result = mammoth.convert_to_html(docx_file)
-            html = f"""
-            <div style="width: 800px; height: 800px; padding: 20px; 
-                       border: 1px solid #ccc; overflow-y: auto;">
-                {result.value}
-            </div>
-            """
-            display(HTML(html))
-
-    def example(self):
-        from docx import Document
-        from edsl.scenarios.Scenario import Scenario
-        from edsl.scenarios.ScenarioList import ScenarioList
-
-        os.makedirs("test_dir", exist_ok=True)
-        doc1 = Document()
-        _ = doc1.add_heading("First Survey")
-        doc1.save("test_dir/test1.docx")
-        doc2 = Document()
-        _ = doc2.add_heading("Second Survey")
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
-            doc2.save(tmp.name)
-            tmp.close()
-
-        return tmp.name
-
-
-if __name__ == "__main__":
-    docx_temp = DocxMethods.example()
-    from edsl.scenarios.FileStore import FileStore
-
-    fs = FileStore(docx_temp)

edsl/scenarios/handlers/html.py

@@ -1,37 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import tempfile
-
-
-class HtmlMethods(FileMethods):
-    suffix = "html"
-
-    def view_system(self):
-        import webbrowser
-
-        # with open(self.path, "r") as f:
-        #     html_string = f.read()
-
-        # html_path = self.to_tempfile()
-        # webbrowser.open("file://" + html_path)
-        webbrowser.open("file://" + self.path)
-
-    def view_notebook(self):
-        from IPython.display import IFrame, display
-
-        display(IFrame(self.path, width=800, height=800))
-
-    def example(self):
-        html_string = b"""
-            <html>
-            <head>
-                <title>Test</title>
-            </head>
-            <body>
-                <h1>Hello, World!</h1>
-            </body>
-            </html>
-            """
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as f:
-            f.write(html_string)
-        return f.name

edsl/scenarios/handlers/json.py

@@ -1,111 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import tempfile
-import json
-from typing import Optional, Dict, Any
-
-
-class JsonMethods(FileMethods):
-    suffix = "json"
-
-    def view_system(self):
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening JSON: {e}")
-        else:
-            print("JSON file was not found.")
-
-    def view_notebook(self):
-        from IPython.display import FileLink, JSON, display
-        import json
-
-        # Read and parse the JSON file
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = json.load(f)
-
-            # Display formatted JSON
-            display(JSON(content))
-
-            # Provide download link
-            display(FileLink(self.path))
-        except json.JSONDecodeError as e:
-            print(f"Error parsing JSON: {e}")
-        except Exception as e:
-            print(f"Error reading file: {e}")
-
-    def validate_json(self, schema: Optional[Dict[str, Any]] = None) -> bool:
-        """
-        Validate the JSON file against a schema if provided,
-        or check if it's valid JSON if no schema is provided.
-        """
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = json.load(f)
-
-            if schema is not None:
-                from jsonschema import validate
-
-                validate(instance=content, schema=schema)
-
-            return True
-        except json.JSONDecodeError as e:
-            print(f"Invalid JSON format: {e}")
-            return False
-        except Exception as e:
-            print(f"Validation error: {e}")
-            return False
-
-    def pretty_print(self):
-        """Pretty print the JSON content with proper indentation."""
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = json.load(f)
-
-            pretty_json = json.dumps(content, indent=2, sort_keys=True)
-            print(pretty_json)
-        except Exception as e:
-            print(f"Error pretty printing JSON: {e}")
-
-    def example(self):
-        sample_json = {
-            "person": {
-                "name": "John Doe",
-                "age": 30,
-                "contact": {"email": "john@example.com", "phone": "+1-555-555-5555"},
-                "interests": ["programming", "data science", "machine learning"],
-                "active": True,
-                "metadata": {"last_updated": "2024-01-01", "version": 1.0},
-            }
-        }
-
-        with tempfile.NamedTemporaryFile(
-            delete=False, suffix=".json", mode="w", encoding="utf-8"
-        ) as f:
-            json.dump(sample_json, f, indent=2)
-        return f.name
-
-    def format_file(self):
-        """Read, format, and write back the JSON with consistent formatting."""
-        try:
-            # Read the current content
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = json.load(f)
-
-            # Write back with consistent formatting
-            with open(self.path, "w", encoding="utf-8") as f:
-                json.dump(content, f, indent=2, sort_keys=True)
-
-            return True
-        except Exception as e:
-            print(f"Error formatting JSON file: {e}")
-            return False

edsl/scenarios/handlers/latex.py

@@ -1,5 +0,0 @@
-from edsl.scenarios.handlers.txt import TxtMethods
-
-
-class LaTeXMethods(TxtMethods):
-    pass

edsl/scenarios/handlers/md.py

@@ -1,51 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import tempfile
-
-
-class MarkdownMethods(FileMethods):
-    suffix = "md"
-
-    def view_system(self):
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening Markdown: {e}")
-        else:
-            print("Markdown file was not found.")
-
-    def view_notebook(self):
-        from IPython.display import FileLink, Markdown, display
-
-        # First display the content of the markdown file
-        with open(self.path, "r", encoding="utf-8") as f:
-            content = f.read()
-            display(Markdown(content))
-
-        # Then provide a download link
-        display(FileLink(self.path))
-
-    def example(self):
-        markdown_content = """# Sample Markdown
-        
-## Features
-- **Bold text** demonstration
-- *Italic text* demonstration
-- Code block example:
-```python
-print("Hello, World!")
-```
-"""
-        with tempfile.NamedTemporaryFile(
-            delete=False, suffix=".md", mode="w", encoding="utf-8"
-        ) as f:
-            f.write(markdown_content)
-        return f.name