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

edsl/scenarios/ScenarioHtmlMixin.py

@@ -1,64 +1,64 @@
-import requests
-from typing import Optional
-from requests.adapters import HTTPAdapter
-from requests.packages.urllib3.util.retry import Retry
-
-
-class ScenarioHtmlMixin:
-    @classmethod
-    def from_html(cls, url: str, field_name: Optional[str] = None) -> "Scenario":
-        """Create a scenario from HTML content.
-
-        :param html: The HTML content.
-        :param field_name: The name of the field containing the HTML content.
-
-
-        """
-        html = cls.fetch_html(url)
-        text = cls.extract_text(html)
-        if not field_name:
-            field_name = "text"
-        return cls({"url": url, "html": html, field_name: text})
-
-    def fetch_html(url):
-        # Define the user-agent to mimic a browser
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-        }
-
-        # Create a session to manage cookies and retries
-        session = requests.Session()
-        retries = Retry(
-            total=5, backoff_factor=0.1, status_forcelist=[500, 502, 503, 504]
-        )
-        session.mount("http://", HTTPAdapter(max_retries=retries))
-        session.mount("https://", HTTPAdapter(max_retries=retries))
-
-        try:
-            # Make the request
-            response = session.get(url, headers=headers, timeout=10)
-            response.raise_for_status()  # Raise an exception for HTTP errors
-            return response.text
-        except requests.exceptions.RequestException as e:
-            print(f"An error occurred: {e}")
-            return None
-
-    def extract_text(html):
-        # Extract text from HTML using BeautifulSoup
-        from bs4 import BeautifulSoup
-
-        soup = BeautifulSoup(html, "html.parser")
-        text = soup.get_text()
-        return text
-
-
-if __name__ == "__main__":
-    # Usage example
-    url = "https://example.com"
-    html = ScenarioHtmlMixin.fetch_html(url)
-    if html:
-        print("Successfully fetched the HTML content.")
-    else:
-        print("Failed to fetch the HTML content.")
-
-    print(html)
+import requests
+from typing import Optional
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry
+
+
+class ScenarioHtmlMixin:
+    @classmethod
+    def from_html(cls, url: str, field_name: Optional[str] = None) -> "Scenario":
+        """Create a scenario from HTML content.
+
+        :param html: The HTML content.
+        :param field_name: The name of the field containing the HTML content.
+
+
+        """
+        html = cls.fetch_html(url)
+        text = cls.extract_text(html)
+        if not field_name:
+            field_name = "text"
+        return cls({"url": url, "html": html, field_name: text})
+
+    def fetch_html(url):
+        # Define the user-agent to mimic a browser
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+
+        # Create a session to manage cookies and retries
+        session = requests.Session()
+        retries = Retry(
+            total=5, backoff_factor=0.1, status_forcelist=[500, 502, 503, 504]
+        )
+        session.mount("http://", HTTPAdapter(max_retries=retries))
+        session.mount("https://", HTTPAdapter(max_retries=retries))
+
+        try:
+            # Make the request
+            response = session.get(url, headers=headers, timeout=10)
+            response.raise_for_status()  # Raise an exception for HTTP errors
+            return response.text
+        except requests.exceptions.RequestException as e:
+            print(f"An error occurred: {e}")
+            return None
+
+    def extract_text(html):
+        # Extract text from HTML using BeautifulSoup
+        from bs4 import BeautifulSoup
+
+        soup = BeautifulSoup(html, "html.parser")
+        text = soup.get_text()
+        return text
+
+
+if __name__ == "__main__":
+    # Usage example
+    url = "https://example.com"
+    html = ScenarioHtmlMixin.fetch_html(url)
+    if html:
+        print("Successfully fetched the HTML content.")
+    else:
+        print("Failed to fetch the HTML content.")
+
+    print(html)

edsl/scenarios/ScenarioJoin.py

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