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

edsl/scenarios/handlers/sqlite.py

@@ -0,0 +1,149 @@
+from edsl.scenarios.file_methods import FileMethods
+import os
+import tempfile
+import sqlite3
+
+
+class SQLiteMethods(FileMethods):
+    suffix = "db"  # or "sqlite", depending on your preference
+
+    def extract_text(self):
+        """
+        Extracts a text representation of the database schema and table contents.
+        """
+        with sqlite3.connect(self.path) as conn:
+            cursor = conn.cursor()
+
+            # Get all table names
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            tables = cursor.fetchall()
+
+            full_text = []
+
+            # For each table, get schema and contents
+            for (table_name,) in tables:
+                # Get table schema
+                cursor.execute(
+                    f"SELECT sql FROM sqlite_master WHERE type='table' AND name='{table_name}';"
+                )
+                schema = cursor.fetchone()[0]
+                full_text.append(f"Table: {table_name}")
+                full_text.append(f"Schema: {schema}")
+
+                # Get table contents
+                cursor.execute(f"SELECT * FROM {table_name};")
+                rows = cursor.fetchall()
+
+                # Get column names
+                column_names = [description[0] for description in cursor.description]
+                full_text.append(f"Columns: {', '.join(column_names)}")
+
+                # Add row data
+                for row in rows:
+                    full_text.append(str(row))
+                full_text.append("\n")
+
+        return "\n".join(full_text)
+
+    def view_system(self):
+        """
+        Opens the database with the system's default SQLite viewer if available.
+        """
+        import os
+        import subprocess
+
+        if os.path.exists(self.path):
+            try:
+                if (os_name := os.name) == "posix":
+                    # Try DB Browser for SQLite on macOS
+                    subprocess.run(
+                        ["open", "-a", "DB Browser for SQLite", self.path], check=True
+                    )
+                elif os_name == "nt":
+                    # Try DB Browser for SQLite on Windows
+                    subprocess.run(["DB Browser for SQLite.exe", self.path], check=True)
+                else:
+                    # Try sqlitebrowser on Linux
+                    subprocess.run(["sqlitebrowser", self.path], check=True)
+            except Exception as e:
+                print(f"Error opening SQLite database: {e}")
+        else:
+            print("SQLite database file was not found.")
+
+    def view_notebook(self):
+        """
+        Displays database contents in a Jupyter notebook.
+        """
+        import pandas as pd
+        from IPython.display import HTML, display
+
+        with sqlite3.connect(self.path) as conn:
+            # Get all table names
+            cursor = conn.cursor()
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            tables = cursor.fetchall()
+
+            html_parts = []
+            for (table_name,) in tables:
+                # Read table into pandas DataFrame
+                df = pd.read_sql_query(f"SELECT * FROM {table_name}", conn)
+
+                # Convert to HTML with styling
+                table_html = f"""
+                <div style="margin-bottom: 20px;">
+                    <h3>{table_name}</h3>
+                    {df.to_html(index=False)}
+                </div>
+                """
+                html_parts.append(table_html)
+
+            # Combine all tables into one scrollable div
+            html = f"""
+            <div style="width: 800px; height: 800px; padding: 20px; 
+                       border: 1px solid #ccc; overflow-y: auto;">
+                {''.join(html_parts)}
+            </div>
+            """
+            display(HTML(html))
+
+    def example(self):
+        """
+        Creates an example SQLite database for testing.
+        """
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".db") as tmp:
+            conn = sqlite3.connect(tmp.name)
+            cursor = conn.cursor()
+
+            # Create a sample table
+            cursor.execute(
+                """
+                CREATE TABLE survey_responses (
+                    id INTEGER PRIMARY KEY,
+                    question TEXT,
+                    response TEXT
+                )
+            """
+            )
+
+            # Insert some sample data
+            sample_data = [
+                (1, "First Survey Question", "Response 1"),
+                (2, "Second Survey Question", "Response 2"),
+            ]
+            cursor.executemany(
+                "INSERT INTO survey_responses (id, question, response) VALUES (?, ?, ?)",
+                sample_data,
+            )
+
+            conn.commit()
+            conn.close()
+            tmp.close()
+
+            return tmp.name
+
+
+if __name__ == "__main__":
+    sqlite_temp = SQLiteMethods.example()
+    from edsl.scenarios.FileStore import FileStore
+
+    fs = FileStore(sqlite_temp)

edsl/scenarios/handlers/txt.py

@@ -0,0 +1,33 @@
+from edsl.scenarios.file_methods import FileMethods
+import tempfile
+
+
+class TxtMethods(FileMethods):
+    suffix = "txt"
+
+    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 TXT: {e}")
+        else:
+            print("TXT file was not found.")
+
+    def view_notebook(self):
+        from IPython.display import FileLink, display
+
+        display(FileLink(self.path))
+
+    def example(self):
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".txt") as f:
+            f.write(b"Hello, World!")
+        return f.name

edsl/scenarios/{ScenarioJoin.py → scenario_join.py}

@@ -1,127 +1,131 @@
-from __future__ import annotations
-from typing import Union, TYPE_CHECKING
-
-# if TYPE_CHECKING:
-from edsl.scenarios.ScenarioList import ScenarioList
-from edsl.scenarios.Scenario import Scenario
-
-
-class ScenarioJoin:
-    """Handles join operations between two ScenarioLists.
-
-    This class encapsulates all join-related logic, making it easier to maintain
-    and extend with other join types (inner, right, full) in the future.
-    """
-
-    def __init__(self, left: "ScenarioList", right: "ScenarioList"):
-        """Initialize join operation with two ScenarioLists.
-
-        Args:
-            left: The left ScenarioList
-            right: The right ScenarioList
-        """
-        self.left = left
-        self.right = right
-
-    def left_join(self, by: Union[str, list[str]]) -> ScenarioList:
-        """Perform a left join between the two ScenarioLists.
-
-        Args:
-            by: String or list of strings representing the key(s) to join on. Cannot be empty.
-
-        Returns:
-            A new ScenarioList containing the joined scenarios
-
-        Raises:
-            ValueError: If by is empty or if any join keys don't exist in both ScenarioLists
-        """
-        self._validate_join_keys(by)
-        by_keys = [by] if isinstance(by, str) else by
-
-        other_dict = self._create_lookup_dict(self.right, by_keys)
-        all_keys = self._get_all_keys()
-
-        return ScenarioList(
-            self._create_joined_scenarios(by_keys, other_dict, all_keys)
-        )
-
-    def _validate_join_keys(self, by: Union[str, list[str]]) -> None:
-        """Validate join keys exist in both ScenarioLists."""
-        if not by:
-            raise ValueError(
-                "Join keys cannot be empty. Please specify at least one key to join on."
-            )
-
-        by_keys = [by] if isinstance(by, str) else by
-        left_keys = set(next(iter(self.left)).keys()) if self.left else set()
-        right_keys = set(next(iter(self.right)).keys()) if self.right else set()
-
-        missing_left = set(by_keys) - left_keys
-        missing_right = set(by_keys) - right_keys
-        if missing_left or missing_right:
-            missing = missing_left | missing_right
-            raise ValueError(f"Join key(s) {missing} not found in both ScenarioLists")
-
-    @staticmethod
-    def _get_key_tuple(scenario: Scenario, keys: list[str]) -> tuple:
-        """Create a tuple of values for the join keys."""
-        return tuple(scenario[k] for k in keys)
-
-    def _create_lookup_dict(self, scenarios: ScenarioList, by_keys: list[str]) -> dict:
-        """Create a lookup dictionary for the right scenarios."""
-        return {
-            self._get_key_tuple(scenario, by_keys): scenario for scenario in scenarios
-        }
-
-    def _get_all_keys(self) -> set:
-        """Get all unique keys from both ScenarioLists."""
-        all_keys = set()
-        for scenario in self.left:
-            all_keys.update(scenario.keys())
-        for scenario in self.right:
-            all_keys.update(scenario.keys())
-        return all_keys
-
-    def _create_joined_scenarios(
-        self, by_keys: list[str], other_dict: dict, all_keys: set
-    ) -> list[Scenario]:
-        """Create the joined scenarios."""
-        new_scenarios = []
-
-        for scenario in self.left:
-            new_scenario = {key: None for key in all_keys}
-            new_scenario.update(scenario)
-
-            key_tuple = self._get_key_tuple(scenario, by_keys)
-            if matching_scenario := other_dict.get(key_tuple):
-                self._handle_matching_scenario(
-                    new_scenario, scenario, matching_scenario, by_keys
-                )
-
-            new_scenarios.append(Scenario(new_scenario))
-
-        return new_scenarios
-
-    def _handle_matching_scenario(
-        self,
-        new_scenario: dict,
-        left_scenario: Scenario,
-        right_scenario: Scenario,
-        by_keys: list[str],
-    ) -> None:
-        """Handle merging of matching scenarios and conflict warnings."""
-        overlapping_keys = set(left_scenario.keys()) & set(right_scenario.keys())
-
-        for key in overlapping_keys:
-            if key not in by_keys and left_scenario[key] != right_scenario[key]:
-                join_conditions = [f"{k}='{left_scenario[k]}'" for k in by_keys]
-                print(
-                    f"Warning: Conflicting values for key '{key}' where "
-                    f"{' AND '.join(join_conditions)}. "
-                    f"Keeping left value: {left_scenario[key]} "
-                    f"(discarding: {right_scenario[key]})"
-                )
-
-        # Only update with non-overlapping keys from matching scenario
-        new_keys = set(right_scenario.keys()) - set(left_scenario.keys())
-        new_scenario.update({k: right_scenario[k] for k in new_keys})
+from __future__ import annotations
+from typing import Union, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from edsl.scenarios.ScenarioList import ScenarioList
+    from edsl.scenarios.Scenario import Scenario
+
+
+class ScenarioJoin:
+    """Handles join operations between two ScenarioLists.
+
+    This class encapsulates all join-related logic, making it easier to maintain
+    and extend with other join types (inner, right, full) in the future.
+    """
+
+    def __init__(self, left: "ScenarioList", right: "ScenarioList"):
+        """Initialize join operation with two ScenarioLists.
+
+        Args:
+            left: The left ScenarioList
+            right: The right ScenarioList
+        """
+        self.left = left
+        self.right = right
+
+    def left_join(self, by: Union[str, list[str]]) -> "ScenarioList":
+        """Perform a left join between the two ScenarioLists.
+
+        Args:
+            by: String or list of strings representing the key(s) to join on. Cannot be empty.
+
+        Returns:
+            A new ScenarioList containing the joined scenarios
+
+        Raises:
+            ValueError: If by is empty or if any join keys don't exist in both ScenarioLists
+        """
+        from edsl.scenarios.ScenarioList import ScenarioList
+
+        self._validate_join_keys(by)
+        by_keys = [by] if isinstance(by, str) else by
+
+        other_dict = self._create_lookup_dict(self.right, by_keys)
+        all_keys = self._get_all_keys()
+
+        return ScenarioList(
+            self._create_joined_scenarios(by_keys, other_dict, all_keys)
+        )
+
+    def _validate_join_keys(self, by: Union[str, list[str]]) -> None:
+        """Validate join keys exist in both ScenarioLists."""
+        if not by:
+            raise ValueError(
+                "Join keys cannot be empty. Please specify at least one key to join on."
+            )
+
+        by_keys = [by] if isinstance(by, str) else by
+        left_keys = set(next(iter(self.left)).keys()) if self.left else set()
+        right_keys = set(next(iter(self.right)).keys()) if self.right else set()
+
+        missing_left = set(by_keys) - left_keys
+        missing_right = set(by_keys) - right_keys
+        if missing_left or missing_right:
+            missing = missing_left | missing_right
+            raise ValueError(f"Join key(s) {missing} not found in both ScenarioLists")
+
+    @staticmethod
+    def _get_key_tuple(scenario: Scenario, keys: list[str]) -> tuple:
+        """Create a tuple of values for the join keys."""
+        return tuple(scenario[k] for k in keys)
+
+    def _create_lookup_dict(self, scenarios: ScenarioList, by_keys: list[str]) -> dict:
+        """Create a lookup dictionary for the right scenarios."""
+        return {
+            self._get_key_tuple(scenario, by_keys): scenario for scenario in scenarios
+        }
+
+    def _get_all_keys(self) -> set:
+        """Get all unique keys from both ScenarioLists."""
+        all_keys = set()
+        for scenario in self.left:
+            all_keys.update(scenario.keys())
+        for scenario in self.right:
+            all_keys.update(scenario.keys())
+        return all_keys
+
+    def _create_joined_scenarios(
+        self, by_keys: list[str], other_dict: dict, all_keys: set
+    ) -> list[Scenario]:
+        """Create the joined scenarios."""
+        from edsl.scenarios.Scenario import Scenario
+
+        new_scenarios = []
+
+        for scenario in self.left:
+            new_scenario = {key: None for key in all_keys}
+            new_scenario.update(scenario)
+
+            key_tuple = self._get_key_tuple(scenario, by_keys)
+            if matching_scenario := other_dict.get(key_tuple):
+                self._handle_matching_scenario(
+                    new_scenario, scenario, matching_scenario, by_keys
+                )
+
+            new_scenarios.append(Scenario(new_scenario))
+
+        return new_scenarios
+
+    def _handle_matching_scenario(
+        self,
+        new_scenario: dict,
+        left_scenario: "Scenario",
+        right_scenario: "Scenario",
+        by_keys: list[str],
+    ) -> None:
+        """Handle merging of matching scenarios and conflict warnings."""
+        overlapping_keys = set(left_scenario.keys()) & set(right_scenario.keys())
+
+        for key in overlapping_keys:
+            if key not in by_keys and left_scenario[key] != right_scenario[key]:
+                join_conditions = [f"{k}='{left_scenario[k]}'" for k in by_keys]
+                print(
+                    f"Warning: Conflicting values for key '{key}' where "
+                    f"{' AND '.join(join_conditions)}. "
+                    f"Keeping left value: {left_scenario[key]} "
+                    f"(discarding: {right_scenario[key]})"
+                )
+
+        # Only update with non-overlapping keys from matching scenario
+        new_keys = set(right_scenario.keys()) - set(left_scenario.keys())
+        new_scenario.update({k: right_scenario[k] for k in new_keys})

edsl/scenarios/scenario_selector.py

@@ -0,0 +1,156 @@
+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/shared.py

@@ -1 +1 @@
-shared_globals = {}
+shared_globals = {}