edsl 0.1.38__py3-none-any.whl → 0.1.38.dev1__py3-none-any.whl

edsl/results/CSSParameterizer.py

@@ -1,108 +0,0 @@
-import re
-from typing import Dict, Set, Optional
-
-
-class CSSParameterizer:
-    """A utility class to parameterize CSS with custom properties (variables)."""
-
-    def __init__(self, css_content: str):
-        """
-        Initialize with CSS content to be parameterized.
-
-        Args:
-            css_content (str): The CSS content containing var() declarations
-        """
-        self.css_content = css_content
-        self._extract_variables()
-
-    def _extract_variables(self) -> None:
-        """Extract all CSS custom properties (variables) from the CSS content."""
-        # Find all var(...) declarations in the CSS
-        var_pattern = r"var\((--[a-zA-Z0-9-]+)\)"
-        self.variables = set(re.findall(var_pattern, self.css_content))
-
-    def _validate_parameters(self, parameters: Dict[str, str]) -> Set[str]:
-        """
-        Validate the provided parameters against the CSS variables.
-
-        Args:
-            parameters (Dict[str, str]): Dictionary of variable names and their values
-
-        Returns:
-            Set[str]: Set of missing variables
-        """
-        # Convert parameter keys to CSS variable format if they don't already have --
-        formatted_params = {
-            f"--{k}" if not k.startswith("--") else k for k in parameters.keys()
-        }
-
-        # print("Variables from CSS:", self.variables)
-        # print("Formatted parameters:", formatted_params)
-
-        # Find missing and extra variables
-        missing_vars = self.variables - formatted_params
-        extra_vars = formatted_params - self.variables
-
-        if extra_vars:
-            print(f"Warning: Found unused parameters: {extra_vars}")
-
-        return missing_vars
-
-    def generate_root(self, **parameters: str) -> Optional[str]:
-        """
-        Generate a :root block with the provided parameters.
-
-        Args:
-            **parameters: Keyword arguments where keys are variable names and values are their values
-
-        Returns:
-            str: Generated :root block with variables, or None if validation fails
-
-        Example:
-            >>> css = "body { height: var(--bodyHeight); }"
-            >>> parameterizer = CSSParameterizer(css)
-            >>> parameterizer.apply_parameters({'bodyHeight':"100vh"})
-            ':root {\\n  --bodyHeight: 100vh;\\n}\\n\\nbody { height: var(--bodyHeight); }'
-        """
-        missing_vars = self._validate_parameters(parameters)
-
-        if missing_vars:
-            print(f"Error: Missing required variables: {missing_vars}")
-            return None
-
-        # Format parameters with -- prefix if not present
-        formatted_params = {
-            f"--{k}" if not k.startswith("--") else k: v for k, v in parameters.items()
-        }
-
-        # Generate the :root block
-        root_block = [":root {"]
-        for var_name, value in sorted(formatted_params.items()):
-            if var_name in self.variables:
-                root_block.append(f"  {var_name}: {value};")
-        root_block.append("}")
-
-        return "\n".join(root_block)
-
-    def apply_parameters(self, parameters: dict) -> Optional[str]:
-        """
-        Generate the complete CSS with the :root block and original CSS content.
-
-        Args:
-            **parameters: Keyword arguments where keys are variable names and values are their values
-
-        Returns:
-            str: Complete CSS with :root block and original content, or None if validation fails
-        """
-        root_block = self.generate_root(**parameters)
-        if root_block is None:
-            return None
-
-        return f"{root_block}\n\n{self.css_content}"
-
-
-# Example usage
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/results/TableDisplay.py

@@ -1,198 +0,0 @@
-from tabulate import tabulate
-from pathlib import Path
-
-from edsl.results.CSSParameterizer import CSSParameterizer
-
-
-class TableDisplay:
-    max_height = 400
-    min_height = 200
-
-    @classmethod
-    def get_css(cls):
-        """Load CSS content from the file next to this module"""
-        css_path = Path(__file__).parent / "table_display.css"
-        return css_path.read_text()
-
-    def __init__(self, headers, data, tablefmt=None, raw_data_set=None):
-        self.headers = headers
-        self.data = data
-        self.tablefmt = tablefmt
-        self.raw_data_set = raw_data_set
-
-        if hasattr(raw_data_set, "print_parameters"):
-            if raw_data_set.print_parameters:
-                self.printing_parameters = raw_data_set.print_parameters
-            else:
-                self.printing_parameters = {}
-        else:
-            self.printing_parameters = {}
-
-    def to_csv(self, filename: str):
-        self.raw_data_set.to_csv(filename)
-
-    def write(self, filename: str):
-        if self.tablefmt is None:
-            table = tabulate(self.data, headers=self.headers, tablefmt="simple")
-        else:
-            table = tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
-
-        with open(filename, "w") as file:
-            print("Writing table to", filename)
-            file.write(table)
-
-    def to_pandas(self):
-        return self.raw_data_set.to_pandas()
-
-    def to_list(self):
-        return self.raw_data_set.to_list()
-
-    def __repr__(self):
-        from tabulate import tabulate
-
-        if self.tablefmt is None:
-            return tabulate(self.data, headers=self.headers, tablefmt="simple")
-        else:
-            return tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
-
-    def long(self):
-        new_header = ["row", "key", "value"]
-        new_data = []
-        for index, row in enumerate(self.data):
-            new_data.extend([[index, k, v] for k, v in zip(self.headers, row)])
-        return TableDisplay(new_header, new_data)
-
-    def _repr_html_(self):
-        if self.tablefmt is not None:
-            return (
-                "<pre>"
-                + tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
-                + "</pre>"
-            )
-
-        num_rows = len(self.data)
-        height = min(
-            num_rows * 30 + 50, self.max_height
-        )  # Added extra space for header
-
-        if height < self.min_height:
-            height = self.min_height
-
-        html_template = """
-        <style>
-            {css}
-        </style>
-        <div class="table-container">
-            <div class="scroll-table-wrapper">
-                {table}
-            </div>
-        </div>
-        """
-
-        html_content = tabulate(self.data, headers=self.headers, tablefmt="html")
-        html_content = html_content.replace("<table>", '<table class="scroll-table">')
-
-        height_string = f"{height}px"
-        parameters = {"containerHeight": height_string, "headerColor": "blue"}
-        parameters.update(self.printing_parameters)
-        rendered_css = CSSParameterizer(self.get_css()).apply_parameters(parameters)
-
-        return html_template.format(table=html_content, css=rendered_css)
-
-    @classmethod
-    def example(
-        cls,
-        headers=None,
-        data=None,
-        filename: str = "table_example.html",
-        auto_open: bool = True,
-    ):
-        """
-        Creates a standalone HTML file with an example table in an iframe and optionally opens it in a new tab.
-
-        Args:
-            cls: The class itself
-            headers (list): List of column headers. If None, uses example headers
-            data (list): List of data rows. If None, uses example data
-            filename (str): The name of the HTML file to create. Defaults to "table_example.html"
-            auto_open (bool): Whether to automatically open the file in the default web browser. Defaults to True
-
-        Returns:
-            str: The path to the created HTML file
-        """
-        import os
-        import webbrowser
-
-        # Use example data if none provided
-        if headers is None:
-            headers = ["Name", "Age", "City", "Occupation"]
-        if data is None:
-            data = [
-                [
-                    "John Doe",
-                    30,
-                    "New York",
-                    """cls: The class itself
-        headers (list): List of column headers. If None, uses example headers
-        data (list): List of data rows. If None, uses example data
-        filename (str): The name of the HTML file to create. Defaults to "table_example.html"
-        auto_open (bool): Whether to automatically open the file in the default web browser. Defaults to True
-        """,
-                ],
-                ["Jane Smith", 28, "San Francisco", "Designer"],
-                ["Bob Johnson", 35, "Chicago", "Manager"],
-                ["Alice Brown", 25, "Boston", "Developer"],
-                ["Charlie Wilson", 40, "Seattle", "Architect"],
-            ]
-
-        # Create instance with the data
-        instance = cls(headers=headers, data=data)
-
-        # Get the table HTML content
-        table_html = instance._repr_html_()
-
-        # Calculate the appropriate iframe height
-        num_rows = len(data)
-        iframe_height = min(num_rows * 140 + 50, cls.max_height)
-        print(f"Table height: {iframe_height}px")
-
-        # Create the full HTML document
-        html_content = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>Table Display Example</title>
-            <style>
-                body {{
-                    margin: 0;
-                    padding: 20px;
-                    font-family: Arial, sans-serif;
-                }}
-                iframe {{
-                    width: 100%;
-                    height: {iframe_height}px;
-                    border: none;
-                    overflow: hidden;
-                }}
-            </style>
-        </head>
-        <body>
-            <iframe srcdoc='{table_html}'></iframe>
-        </body>
-        </html>
-        """
-
-        # Write the HTML file
-        abs_path = os.path.abspath(filename)
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write(html_content)
-
-        # Open in browser if requested
-        if auto_open:
-            webbrowser.open("file://" + abs_path, new=2)
-
-        return abs_path
-
-
-if __name__ == "__main__":
-    TableDisplay.example()

edsl/results/table_display.css

@@ -1,78 +0,0 @@
-.table-container {
-    height: var(--containerHeight) !important;
-    width: 100%;
-    overflow: auto;  /* This enables both horizontal and vertical scrolling */
-    border: 1px solid #d4d4d4;
-    background: transparent;
-    position: relative;  /* Create stacking context for sticky header */
-}
-
-.scroll-table {
-    /* Remove width: 100% to prevent table from being constrained */
-    /* min-width: 100% ensures table takes at least full container width */
-    min-width: 100%;
-    border-collapse: separate;
-    border-spacing: 4px;
-    background: transparent;
-    table-layout: auto;  /* Allow table to size based on content */
-}
-
-.scroll-table th {
-    background: transparent;  /* Semi-transparent background to ensure text readability */
-    position: sticky;
-    top: 0;
-    z-index: 1;
-    text-align: left !important;
-    padding: 8px;
-    font-weight: bold;
-    white-space: nowrap;  /* Prevent header text from wrapping */
-    min-width: 100px;    /* Ensure minimum column width */
-    backdrop-filter: blur(8px);  /* Optional: adds extra clarity */
-    color: var(--headerColor);
-}
-
-.scroll-table td {
-    padding: 8px;
-    text-align: left !important;
-    white-space: pre-wrap;
-    word-wrap: break-word;
-    vertical-align: top;
-    color: inherit;
-    border-bottom: none;
-    background: transparent;
-    min-width: 100px;    /* Match header minimum width */
-}
-
-.scroll-table tbody tr:hover {
-    background: transparent;
-}
-
-/* Additional rule to ensure header background is truly transparent */
-.scroll-table thead tr {
-    background: transparent !important;
-}
-
-/* Add shadow to indicate scrollable content */
-.table-container::after {
-    content: '';
-    position: absolute;
-    top: 0;
-    right: 0;
-    bottom: 0;
-    width: 5px;
-    background: linear-gradient(to right, transparent, rgba(242, 6, 6, 0.1));
-    pointer-events: none;
-    opacity: 0;
-    transition: opacity 0.3s;
-}
-
-.table-container:hover::after {
-    opacity: 1;
-}
-
-/* Handle Jupyter notebook specific styling */
-.jp-OutputArea-output .table-container {
-    max-width: 100%;
-    margin: 0;
-    overflow-x: auto;
-}

edsl/scenarios/ScenarioJoin.py

@@ -1,127 +0,0 @@
-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})