edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/jobs/JobsRemoteInferenceHandler.py

@@ -1,47 +1,78 @@
-from typing import Optional, Union, Literal
-import requests
-import sys
+from typing import Optional, Union, Literal, TYPE_CHECKING, NewType, Callable, Any
+
+from dataclasses import dataclass
+
+
+Seconds = NewType("Seconds", float)
+JobUUID = NewType("JobUUID", str)
+
 from edsl.exceptions.coop import CoopServerResponseError
 
-# from edsl.enums import VisibilityType
-from edsl.results import Results
+if TYPE_CHECKING:
+    from edsl.results.Results import Results
+    from edsl.jobs.Jobs import Jobs
+    from edsl.coop.coop import RemoteInferenceResponse, RemoteInferenceCreationInfo
+    from edsl.jobs.JobsRemoteInferenceLogger import JobLogger
+
+from edsl.coop.coop import RemoteInferenceResponse, RemoteInferenceCreationInfo
+
+from edsl.jobs.jobs_status_enums import JobsStatus
+from edsl.coop.utils import VisibilityType
+from edsl.jobs.JobsRemoteInferenceLogger import JobLogger
+
+
+class RemoteJobConstants:
+    """Constants for remote job handling."""
+
+    REMOTE_JOB_POLL_INTERVAL = 1
+    REMOTE_JOB_VERBOSE = False
+    DISCORD_URL = "https://discord.com/invite/mxAYkjfy9m"
+
+
+@dataclass
+class RemoteJobInfo:
+    creation_data: RemoteInferenceCreationInfo
+    job_uuid: JobUUID
+    logger: JobLogger
 
 
 class JobsRemoteInferenceHandler:
-    def __init__(self, jobs, verbose=False, poll_interval=3):
-        """
-        >>> from edsl.jobs import Jobs
-        >>> jh = JobsRemoteInferenceHandler(Jobs.example(), verbose=True)
-        >>> jh.use_remote_inference(True)
-        False
-        >>> jh._poll_remote_inference_job({'uuid':1234}, testing_simulated_response={"status": "failed"}) # doctest: +NORMALIZE_WHITESPACE
-        Job failed.
-        ...
-        >>> jh._poll_remote_inference_job({'uuid':1234}, testing_simulated_response={"status": "completed"}) # doctest: +NORMALIZE_WHITESPACE
-        Job completed and Results stored on Coop: None.
-        Results(...)
-        """
+    def __init__(
+        self,
+        jobs: "Jobs",
+        verbose: bool = RemoteJobConstants.REMOTE_JOB_VERBOSE,
+        poll_interval: Seconds = RemoteJobConstants.REMOTE_JOB_POLL_INTERVAL,
+    ):
+        """Handles the creation and running of a remote inference job."""
         self.jobs = jobs
         self.verbose = verbose
         self.poll_interval = poll_interval
 
-        self._remote_job_creation_data = None
-        self._job_uuid = None
+        from edsl.config import CONFIG
+
+        self.expected_parrot_url = CONFIG.get("EXPECTED_PARROT_URL")
+        self.remote_inference_url = f"{self.expected_parrot_url}/home/remote-inference"
 
-    @property
-    def remote_job_creation_data(self):
-        return self._remote_job_creation_data
+    def _create_logger(self) -> JobLogger:
+        from edsl.utilities.is_notebook import is_notebook
+        from edsl.jobs.JobsRemoteInferenceLogger import (
+            JupyterJobLogger,
+            StdOutJobLogger,
+        )
+        from edsl.jobs.loggers.HTMLTableJobLogger import HTMLTableJobLogger
 
-    @property
-    def job_uuid(self):
-        return self._job_uuid
+        if is_notebook():
+            return HTMLTableJobLogger(verbose=self.verbose)
+        return StdOutJobLogger(verbose=self.verbose)
 
     def use_remote_inference(self, disable_remote_inference: bool) -> bool:
+        import requests
+
         if disable_remote_inference:
             return False
         if not disable_remote_inference:
             try:
-                from edsl import Coop
+                from edsl.coop.coop import Coop
 
                 user_edsl_settings = Coop().edsl_settings
                 return user_edsl_settings.get("remote_inference", False)
@@ -56,16 +87,19 @@ class JobsRemoteInferenceHandler:
         self,
         iterations: int = 1,
         remote_inference_description: Optional[str] = None,
-        remote_inference_results_visibility: Optional["VisibilityType"] = "unlisted",
-        verbose=False,
-    ):
-        """ """
+        remote_inference_results_visibility: Optional[VisibilityType] = "unlisted",
+    ) -> RemoteJobInfo:
+
         from edsl.config import CONFIG
         from edsl.coop.coop import Coop
-        from rich import print as rich_print
+
+        logger = self._create_logger()
 
         coop = Coop()
-        print("Remote inference activated. Sending job to server...")
+        logger.update(
+            "Remote inference activated. Sending job to server...",
+            status=JobsStatus.QUEUED,
+        )
         remote_job_creation_data = coop.remote_inference_create(
             self.jobs,
             description=remote_inference_description,
@@ -73,136 +107,172 @@ class JobsRemoteInferenceHandler:
             iterations=iterations,
             initial_results_visibility=remote_inference_results_visibility,
         )
+        logger.update(
+            "Your survey is running at the Expected Parrot server...",
+            status=JobsStatus.RUNNING,
+        )
         job_uuid = remote_job_creation_data.get("uuid")
-        print(f"Job sent to server. (Job uuid={job_uuid}).")
-
-        expected_parrot_url = CONFIG.get("EXPECTED_PARROT_URL")
-        progress_bar_url = f"{expected_parrot_url}/home/remote-job-progress/{job_uuid}"
+        logger.update(
+            message=f"Job sent to server. (Job uuid={job_uuid}).",
+            status=JobsStatus.RUNNING,
+        )
+        logger.add_info("job_uuid", job_uuid)
 
-        rich_print(
-            f"View job progress here: [#38bdf8][link={progress_bar_url}]{progress_bar_url}[/link][/#38bdf8]"
+        logger.update(
+            f"Job details are available at your Coop account {self.remote_inference_url}",
+            status=JobsStatus.RUNNING,
+        )
+        progress_bar_url = (
+            f"{self.expected_parrot_url}/home/remote-job-progress/{job_uuid}"
+        )
+        logger.add_info("progress_bar_url", progress_bar_url)
+        logger.update(
+            f"View job progress here: {progress_bar_url}", status=JobsStatus.RUNNING
         )
 
-        self._remote_job_creation_data = remote_job_creation_data
-        self._job_uuid = job_uuid
-        # return remote_job_creation_data
+        return RemoteJobInfo(
+            creation_data=remote_job_creation_data,
+            job_uuid=job_uuid,
+            logger=logger,
+        )
 
     @staticmethod
-    def check_status(job_uuid):
+    def check_status(
+        job_uuid: JobUUID,
+    ) -> RemoteInferenceResponse:
         from edsl.coop.coop import Coop
 
         coop = Coop()
         return coop.remote_inference_get(job_uuid)
 
-    def poll_remote_inference_job(self):
-        return self._poll_remote_inference_job(
-            self.remote_job_creation_data, verbose=self.verbose
+    def _construct_remote_job_fetcher(
+        self, testing_simulated_response: Optional[Any] = None
+    ) -> Callable:
+        if testing_simulated_response is not None:
+            return lambda job_uuid: testing_simulated_response
+        else:
+            from edsl.coop.coop import Coop
+
+            coop = Coop()
+            return coop.remote_inference_get
+
+    def _construct_object_fetcher(
+        self, testing_simulated_response: Optional[Any] = None
+    ) -> Callable:
+        "Constructs a function to fetch the results object from Coop."
+        if testing_simulated_response is not None:
+            return lambda results_uuid, expected_object_type: Results.example()
+        else:
+            from edsl.coop.coop import Coop
+
+            coop = Coop()
+            return coop.get
+
+    def _handle_cancelled_job(self, job_info: RemoteJobInfo) -> None:
+        "Handles a cancelled job by logging the cancellation and updating the job status."
+
+        job_info.logger.update(
+            message="Job cancelled by the user.", status=JobsStatus.CANCELLED
+        )
+        job_info.logger.update(
+            f"See {self.expected_parrot_url}/home/remote-inference for more details.",
+            status=JobsStatus.CANCELLED,
         )
 
-    def _poll_remote_inference_job(
-        self,
-        remote_job_creation_data: dict,
-        verbose=False,
-        poll_interval: Optional[float] = None,
-        testing_simulated_response: Optional[dict] = None,
-    ) -> Union[Results, None]:
+    def _handle_failed_job(
+        self, job_info: RemoteJobInfo, remote_job_data: RemoteInferenceResponse
+    ) -> None:
+        "Handles a failed job by logging the error and updating the job status."
+        latest_error_report_url = remote_job_data.get("latest_error_report_url")
+        if latest_error_report_url:
+            job_info.logger.add_info("error_report_url", latest_error_report_url)
+
+        job_info.logger.update("Job failed.", status=JobsStatus.FAILED)
+        job_info.logger.update(
+            f"See {self.expected_parrot_url}/home/remote-inference for more details.",
+            status=JobsStatus.FAILED,
+        )
+        job_info.logger.update(
+            f"Need support? Visit Discord: {RemoteJobConstants.DISCORD_URL}",
+            status=JobsStatus.FAILED,
+        )
+
+    def _sleep_for_a_bit(self, job_info: RemoteJobInfo, status: str) -> None:
         import time
         from datetime import datetime
-        from edsl.config import CONFIG
-        from edsl.coop.coop import Coop
 
-        if poll_interval is None:
-            poll_interval = self.poll_interval
+        time_checked = datetime.now().strftime("%Y-%m-%d %I:%M:%S %p")
+        job_info.logger.update(
+            f"Job status: {status} - last update: {time_checked}",
+            status=JobsStatus.RUNNING,
+        )
+        time.sleep(self.poll_interval)
 
-        expected_parrot_url = CONFIG.get("EXPECTED_PARROT_URL")
+    def _fetch_results_and_log(
+        self,
+        job_info: RemoteJobInfo,
+        results_uuid: str,
+        remote_job_data: RemoteInferenceResponse,
+        object_fetcher: Callable,
+    ) -> "Results":
+        "Fetches the results object and logs the results URL."
+        job_info.logger.add_info("results_uuid", results_uuid)
+        results = object_fetcher(results_uuid, expected_object_type="results")
+        results_url = remote_job_data.get("results_url")
+        job_info.logger.update(
+            f"Job completed and Results stored on Coop: {results_url}",
+            status=JobsStatus.COMPLETED,
+        )
+        results.job_uuid = job_info.job_uuid
+        results.results_uuid = results_uuid
+        return results
 
-        job_uuid = remote_job_creation_data.get("uuid")
-        coop = Coop()
+    def poll_remote_inference_job(
+        self,
+        job_info: RemoteJobInfo,
+        testing_simulated_response=None,
+    ) -> Union[None, "Results"]:
+        """Polls a remote inference job for completion and returns the results."""
 
-        if testing_simulated_response is not None:
-            remote_job_data_fetcher = lambda job_uuid: testing_simulated_response
-            object_fetcher = (
-                lambda results_uuid, expected_object_type: Results.example()
-            )
-        else:
-            remote_job_data_fetcher = coop.remote_inference_get
-            object_fetcher = coop.get
+        remote_job_data_fetcher = self._construct_remote_job_fetcher(
+            testing_simulated_response
+        )
+        object_fetcher = self._construct_object_fetcher(testing_simulated_response)
 
         job_in_queue = True
         while job_in_queue:
-            remote_job_data = remote_job_data_fetcher(job_uuid)
+            remote_job_data = remote_job_data_fetcher(job_info.job_uuid)
             status = remote_job_data.get("status")
+
             if status == "cancelled":
-                print("\r" + " " * 80 + "\r", end="")
-                print("Job cancelled by the user.")
-                print(
-                    f"See {expected_parrot_url}/home/remote-inference for more details."
-                )
-                return None
-            elif status == "failed":
-                print("\r" + " " * 80 + "\r", end="")
-                # write to stderr
-                latest_error_report_url = remote_job_data.get("latest_error_report_url")
-                if latest_error_report_url:
-                    print("Job failed.")
-                    print(
-                        f"Your job generated exceptions. Details on these exceptions can be found in the following report: {latest_error_report_url}"
-                    )
-                    print(
-                        f"Need support? Post a message at the Expected Parrot Discord channel (https://discord.com/invite/mxAYkjfy9m) or send an email to info@expectedparrot.com."
-                    )
-                else:
-                    print("Job failed.")
-                    print(
-                        f"See {expected_parrot_url}/home/remote-inference for more details."
-                    )
+                self._handle_cancelled_job(job_info)
                 return None
-            elif status == "completed":
-                results_uuid = remote_job_data.get("results_uuid")
-                results_url = remote_job_data.get("results_url")
-                results = object_fetcher(results_uuid, expected_object_type="results")
-                print("\r" + " " * 80 + "\r", end="")
-                print(f"Job completed and Results stored on Coop: {results_url}.")
-                return results
-            else:
-                duration = poll_interval
-                time_checked = datetime.now().strftime("%Y-%m-%d %I:%M:%S %p")
-                frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-                start_time = time.time()
-                i = 0
-                while time.time() - start_time < duration:
-                    print(
-                        f"\r{frames[i % len(frames)]} Job status: {status} - last update: {time_checked}",
-                        end="",
-                        flush=True,
-                    )
-                    time.sleep(0.1)
-                    i += 1
 
-    def use_remote_inference(self, disable_remote_inference: bool) -> bool:
-        if disable_remote_inference:
-            return False
-        if not disable_remote_inference:
-            try:
-                from edsl import Coop
+            elif status == "failed" or status == "completed":
+                if status == "failed":
+                    self._handle_failed_job(job_info, remote_job_data)
 
-                user_edsl_settings = Coop().edsl_settings
-                return user_edsl_settings.get("remote_inference", False)
-            except requests.ConnectionError:
-                pass
-            except CoopServerResponseError as e:
-                pass
+                results_uuid = remote_job_data.get("results_uuid")
+                if results_uuid:
+                    results = self._fetch_results_and_log(
+                        job_info=job_info,
+                        results_uuid=results_uuid,
+                        remote_job_data=remote_job_data,
+                        object_fetcher=object_fetcher,
+                    )
+                    return results
+                else:
+                    return None
 
-        return False
+            else:
+                self._sleep_for_a_bit(job_info, status)
 
     async def create_and_poll_remote_job(
         self,
         iterations: int = 1,
         remote_inference_description: Optional[str] = None,
-        remote_inference_results_visibility: Optional[
-            Literal["private", "public", "unlisted"]
-        ] = "unlisted",
-    ) -> Union[Results, None]:
+        remote_inference_results_visibility: Optional[VisibilityType] = "unlisted",
+    ) -> Union["Results", None]:
         """
         Creates and polls a remote inference job asynchronously.
         Reuses existing synchronous methods but runs them in an async context.
@@ -217,7 +287,7 @@ class JobsRemoteInferenceHandler:
 
         # Create job using existing method
         loop = asyncio.get_event_loop()
-        remote_job_creation_data = await loop.run_in_executor(
+        job_info = await loop.run_in_executor(
             None,
             partial(
                 self.create_remote_inference_job,
@@ -226,10 +296,12 @@ class JobsRemoteInferenceHandler:
                 remote_inference_results_visibility=remote_inference_results_visibility,
             ),
         )
+        if job_info is None:
+            raise ValueError("Remote job creation failed.")
 
-        # Poll using existing method but with async sleep
         return await loop.run_in_executor(
-            None, partial(self.poll_remote_inference_job, remote_job_creation_data)
+            None,
+            partial(self.poll_remote_inference_job, job_info),
         )
 
 

edsl/jobs/JobsRemoteInferenceLogger.py

@@ -0,0 +1,239 @@
+import re
+import sys
+import uuid
+from abc import ABC, abstractmethod
+from typing import Optional, Union, Literal, TYPE_CHECKING, List, Dict
+from datetime import datetime
+from dataclasses import dataclass
+from edsl.exceptions.coop import CoopServerResponseError
+
+from edsl.jobs.jobs_status_enums import JobsStatus
+
+if TYPE_CHECKING:
+    from edsl.results.Results import Results
+
+
+@dataclass
+class LogMessage:
+    text: str
+    status: str
+    timestamp: datetime
+    status: JobsStatus
+
+
+@dataclass
+class JobsInfo:
+    job_uuid: str = None
+    progress_bar_url: str = None
+    error_report_url: str = None
+    results_uuid: str = None
+    results_url: str = None
+
+    pretty_names = {
+        "job_uuid": "Job UUID",
+        "progress_bar_url": "Progress Bar URL",
+        "error_report_url": "Error Report URL",
+        "results_uuid": "Results UUID",
+        "results_url": "Results URL",
+    }
+
+
+class JobLogger(ABC):
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.jobs_info = JobsInfo()
+
+    def add_info(
+        self,
+        information_type: Literal[
+            "job_uuid",
+            "progress_bar_url",
+            "error_report_url",
+            "results_uuid",
+            "results_url",
+        ],
+        value: str,
+    ):
+        """Add information to the logger
+
+        >>> j = StdOutJobLogger()
+        >>> j.add_info("job_uuid", "1234")
+        >>> j.jobs_info.job_uuid
+        '1234'
+        """
+        if information_type not in self.jobs_info.__annotations__:
+            raise ValueError(f"Information type {information_type} not supported")
+        setattr(self.jobs_info, information_type, value)
+
+    @abstractmethod
+    def update(self, message: str, status: str = "running"):
+        pass
+
+
+class HTMLTableJobLogger(JobLogger):
+    def __init__(self, verbose=True, **kwargs):
+        from IPython.display import display, HTML
+
+        super().__init__(verbose=verbose)
+        self.display_handle = display(HTML(""), display_id=True)
+        self.current_message = None
+        self.log_id = str(uuid.uuid4())
+        self.is_expanded = True
+        self.spinner_chars = ["◐", "◓", "◑", "◒"]  # Rotating spinner characters
+        self.spinner_idx = 0
+
+    def _get_table_row(self, key: str, value: str) -> str:
+        """Generate a table row with key-value pair"""
+        return f"""
+            <tr>
+                <td style="padding: 8px; border: 1px solid #ddd; font-weight: bold;">{key}</td>
+                <td style="padding: 8px; border: 1px solid #ddd;">{value if value else 'None'}</td>
+            </tr>
+        """
+
+    def _linkify(self, text: str) -> str:
+        """Convert URLs in text to clickable links"""
+        url_pattern = r'(https?://[^\s<>"]+|www\.[^\s<>"]+)'
+        return re.sub(
+            url_pattern,
+            r'<a href="\1" target="_blank" style="color: #3b82f6; text-decoration: underline;">\1</a>',
+            text,
+        )
+
+    def _get_spinner(self, status: JobsStatus) -> str:
+        """Get the current spinner frame if status is running"""
+        if status == JobsStatus.RUNNING:
+            spinner = self.spinner_chars[self.spinner_idx]
+            self.spinner_idx = (self.spinner_idx + 1) % len(self.spinner_chars)
+            return f'<span style="margin-right: 8px;">{spinner}</span>'
+        elif status == JobsStatus.COMPLETED:
+            return '<span style="margin-right: 8px; color: #22c55e;">✓</span>'
+        elif status == JobsStatus.FAILED:
+            return '<span style="margin-right: 8px; color: #ef4444;">✗</span>'
+        return ""
+
+    def _get_html(self, status: JobsStatus = JobsStatus.RUNNING) -> str:
+        """Generate the complete HTML display"""
+        # Generate table rows for each JobsInfo field
+        info_rows = ""
+        for field, _ in self.jobs_info.__annotations__.items():
+            if field != "pretty_names":  # Skip the pretty_names dictionary
+                value = getattr(self.jobs_info, field)
+                value = self._linkify(str(value)) if value else None
+                pretty_name = self.jobs_info.pretty_names.get(
+                    field, field.replace("_", " ").title()
+                )
+                info_rows += self._get_table_row(pretty_name, value)
+
+        # Add current message section with spinner
+        message_html = ""
+        if self.current_message:
+            spinner = self._get_spinner(status)
+            message_html = f"""
+                <div style="margin-top: 10px; padding: 8px; background-color: #f8f9fa; border: 1px solid #ddd; border-radius: 4px;">
+                    {spinner}<strong>Current Status:</strong> {self._linkify(self.current_message)}
+                </div>
+            """
+
+        display_style = "block" if self.is_expanded else "none"
+        arrow = "▼" if self.is_expanded else "▶"
+
+        return f"""
+            <div style="font-family: system-ui; max-width: 800px; margin: 10px 0;">
+                <div onclick="document.getElementById('content-{self.log_id}').style.display = document.getElementById('content-{self.log_id}').style.display === 'none' ? 'block' : 'none';
+                             document.getElementById('arrow-{self.log_id}').innerHTML = document.getElementById('content-{self.log_id}').style.display === 'none' ? '▶' : '▼';"
+                     style="padding: 10px; background: #f5f5f5; border: 1px solid #ddd; border-radius: 4px; cursor: pointer;">
+                    <span id="arrow-{self.log_id}">{arrow}</span> Job Status ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})
+                </div>
+                <div id="content-{self.log_id}" style="display: {display_style};">
+                    <table style="width: 100%; border-collapse: collapse; background: white; border: 1px solid #ddd;">
+                        {info_rows}
+                    </table>
+                    {message_html}
+                </div>
+            </div>
+        """
+
+    def update(self, message: str, status: JobsStatus = JobsStatus.RUNNING):
+        """Update the display with new message and current JobsInfo state"""
+        from IPython.display import HTML
+
+        self.current_message = message
+        if self.verbose:
+            self.display_handle.update(HTML(self._get_html(status)))
+        else:
+            return None
+
+
+class StdOutJobLogger(JobLogger):
+    def __init__(self, verbose=True, **kwargs):
+        super().__init__(verbose=verbose)  # Properly call parent's __init__
+        self.messages: List[LogMessage] = []
+
+    def update(self, message: str, status: JobsStatus = JobsStatus.RUNNING):
+        log_msg = LogMessage(text=message, status=status, timestamp=datetime.now())
+        self.messages.append(log_msg)
+        if self.verbose:
+            sys.stdout.write(f"│ {message}\n")
+            sys.stdout.flush()
+        else:
+            return None
+
+
+class JupyterJobLogger(JobLogger):
+    def __init__(self, verbose=True, **kwargs):
+        from IPython.display import display, HTML
+
+        super().__init__(verbose=verbose)
+        self.messages = []
+        self.log_id = str(uuid.uuid4())
+        self.is_expanded = True
+        self.display_handle = display(HTML(""), display_id=True)
+
+    def _linkify(self, text):
+        url_pattern = r'(https?://[^\s<>"]+|www\.[^\s<>"]+)'
+        return re.sub(
+            url_pattern,
+            r'<a href="\1" target="_blank" style="color: #3b82f6; text-decoration: underline;">\1</a>',
+            text,
+        )
+
+    def _get_html(self):
+        messages_html = "\n".join(
+            [
+                f'<div style="border-left: 3px solid {msg["color"]}; padding: 5px 10px; margin: 5px 0;">{self._linkify(msg["text"])}</div>'
+                for msg in self.messages
+            ]
+        )
+
+        display_style = "block" if self.is_expanded else "none"
+        arrow = "▼" if self.is_expanded else "▶"
+
+        return f"""
+            <div style="border: 1px solid #ccc; margin: 10px 0; max-width: 800px;">
+                <div onclick="document.getElementById('content-{self.log_id}').style.display = document.getElementById('content-{self.log_id}').style.display === 'none' ? 'block' : 'none';
+                             document.getElementById('arrow-{self.log_id}').innerHTML = document.getElementById('content-{self.log_id}').style.display === 'none' ? '▶' : '▼';"
+                     style="padding: 10px; background: #f5f5f5; cursor: pointer;">
+                    <span id="arrow-{self.log_id}">{arrow}</span> Remote Job Log ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})
+                </div>
+                <div id="content-{self.log_id}" style="padding: 10px; display: {display_style};">
+                    {messages_html}
+                </div>
+            </div>
+        """
+
+    def update(self, message, status: JobsStatus = JobsStatus.RUNNING):
+        from IPython.display import HTML
+
+        colors = {"running": "#3b82f6", "completed": "#22c55e", "failed": "#ef4444"}
+        self.messages.append({"text": message, "color": colors.get(status, "#666")})
+        if self.verbose:
+            self.display_handle.update(HTML(self._get_html()))
+        else:
+            return None
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()