edsl 0.1.41__py3-none-any.whl → 0.1.43__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.41"
+__version__ = "0.1.43"

edsl/agents/Invigilator.py

@@ -1,6 +1,6 @@
 """Module for creating Invigilators, which are objects to administer a question to an Agent."""
 
-from typing import Dict, Any, Optional, TYPE_CHECKING
+from typing import Dict, Any, Optional, TYPE_CHECKING, Literal
 
 from edsl.utilities.decorators import sync_wrapper
 from edsl.exceptions.questions import QuestionAnswerValidationError
@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from edsl.scenarios.Scenario import Scenario
     from edsl.surveys.Survey import Survey
 
+PromptType = Literal["user_prompt", "system_prompt", "encoded_image", "files_list"]
 
 NA = "Not Applicable"
 
@@ -19,7 +20,7 @@ NA = "Not Applicable"
 class InvigilatorAI(InvigilatorBase):
     """An invigilator that uses an AI model to answer questions."""
 
-    def get_prompts(self) -> Dict[str, "Prompt"]:
+    def get_prompts(self) -> Dict[PromptType, "Prompt"]:
         """Return the prompts used."""
         return self.prompt_constructor.get_prompts()
 
@@ -155,7 +156,7 @@ class InvigilatorAI(InvigilatorBase):
                         self.question.question_options = new_question_options
 
                 question_with_validators = self.question.render(
-                    self.scenario | prior_answers_dict
+                    self.scenario | prior_answers_dict | {'agent':self.agent.traits}
                 )
                 question_with_validators.use_code = self.question.use_code
             else:

edsl/agents/InvigilatorBase.py

@@ -135,6 +135,7 @@ class InvigilatorBase(ABC):
         d["additional_prompt_data"] = data["additional_prompt_data"]
 
         d = cls(**d)
+        return d
 
     def __repr__(self) -> str:
         """Return a string representation of the Invigilator.
@@ -143,7 +144,7 @@ class InvigilatorBase(ABC):
         'InvigilatorExample(...)'
 
         """
-        return f"{self.__class__.__name__}(agent={repr(self.agent)}, question={repr(self.question)}, scneario={repr(self.scenario)}, model={repr(self.model)}, memory_plan={repr(self.memory_plan)}, current_answers={repr(self.current_answers)}, iteration{repr(self.iteration)}, additional_prompt_data={repr(self.additional_prompt_data)}, cache={repr(self.cache)})"
+        return f"{self.__class__.__name__}(agent={repr(self.agent)}, question={repr(self.question)}, scenario={repr(self.scenario)}, model={repr(self.model)}, memory_plan={repr(self.memory_plan)}, current_answers={repr(self.current_answers)}, iteration={repr(self.iteration)}, additional_prompt_data={repr(self.additional_prompt_data)}, cache={repr(self.cache)})"
 
     def get_failed_task_result(self, failure_reason: str) -> EDSLResultObjectInput:
         """Return an AgentResponseDict used in case the question-asking fails.

edsl/agents/PromptConstructor.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional, Set, Union, TYPE_CHECKING
+from typing import Dict, Any, Optional, Set, Union, TYPE_CHECKING, Literal
 from functools import cached_property
+from multiprocessing import Pool, freeze_support, get_context
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+import time
+import logging
 
 from edsl.prompts.Prompt import Prompt
 
@@ -22,6 +26,7 @@ if TYPE_CHECKING:
     from edsl.questions.QuestionBase import QuestionBase
     from edsl.scenarios.Scenario import Scenario
 
+logger = logging.getLogger(__name__)
 
 class BasePlaceholder:
     """Base class for placeholder values when a question is not yet answered."""
@@ -242,31 +247,97 @@ class PromptConstructor:
             question_name, self.current_answers
         )
 
-    def get_prompts(self) -> Dict[str, Prompt]:
-        """Get both prompts for the LLM call.
-
-        >>> from edsl import QuestionFreeText
-        >>> from edsl.agents.InvigilatorBase import InvigilatorBase
-        >>> q = QuestionFreeText(question_text="How are you today?", question_name="q_new")
-        >>> i = InvigilatorBase.example(question = q)
-        >>> i.get_prompts()
-        {'user_prompt': ..., 'system_prompt': ...}
-        """
-        prompts = self.prompt_plan.get_prompts(
-            agent_instructions=self.agent_instructions_prompt,
-            agent_persona=self.agent_persona_prompt,
-            question_instructions=Prompt(self.question_instructions_prompt),
-            prior_question_memory=self.prior_question_memory_prompt,
-        )
-        if self.question_file_keys:
+    def get_prompts(self, parallel: Literal["thread", "process", None] = None) -> Dict[str, Any]:
+        """Get the prompts for the question."""
+        start = time.time()
+        
+        # Build all the components
+        instr_start = time.time()
+        agent_instructions = self.agent_instructions_prompt
+        instr_end = time.time()
+        logger.debug(f"Time taken for agent instructions: {instr_end - instr_start:.4f}s")
+        
+        persona_start = time.time()
+        agent_persona = self.agent_persona_prompt
+        persona_end = time.time()
+        logger.debug(f"Time taken for agent persona: {persona_end - persona_start:.4f}s")
+        
+        q_instr_start = time.time()
+        question_instructions = self.question_instructions_prompt
+        q_instr_end = time.time()
+        logger.debug(f"Time taken for question instructions: {q_instr_end - q_instr_start:.4f}s")
+        
+        memory_start = time.time()
+        prior_question_memory = self.prior_question_memory_prompt
+        memory_end = time.time()
+        logger.debug(f"Time taken for prior question memory: {memory_end - memory_start:.4f}s")
+
+        # Get components dict
+        components = {
+            "agent_instructions": agent_instructions.text,
+            "agent_persona": agent_persona.text,
+            "question_instructions": question_instructions.text,
+            "prior_question_memory": prior_question_memory.text,
+        }
+
+        # Use PromptPlan's get_prompts method
+        plan_start = time.time()
+        
+        # Get arranged components first
+        arranged = self.prompt_plan.arrange_components(**components)
+        
+        if parallel == "process":
+            ctx = get_context('fork')
+            with ctx.Pool() as pool:
+                results = pool.map(_process_prompt, [
+                    (arranged["user_prompt"], {}),
+                    (arranged["system_prompt"], {})
+                ])
+                prompts = {
+                    "user_prompt": results[0],
+                    "system_prompt": results[1]
+                }
+            
+        elif parallel == "thread":
+            with ThreadPoolExecutor() as executor:
+                user_prompt_list = arranged["user_prompt"]
+                system_prompt_list = arranged["system_prompt"]
+                
+                # Process both prompt lists in parallel
+                rendered_user = executor.submit(_process_prompt, (user_prompt_list, {}))
+                rendered_system = executor.submit(_process_prompt, (system_prompt_list, {}))
+                
+                prompts = {
+                    "user_prompt": rendered_user.result(),
+                    "system_prompt": rendered_system.result()
+                }
+                
+        else:  # sequential processing
+            prompts = self.prompt_plan.get_prompts(**components)
+
+        plan_end = time.time()
+        logger.debug(f"Time taken for prompt processing: {plan_end - plan_start:.4f}s")
+        
+        # Handle file keys if present
+        if hasattr(self, 'question_file_keys') and self.question_file_keys:
+            files_start = time.time()
             files_list = []
             for key in self.question_file_keys:
                 files_list.append(self.scenario[key])
             prompts["files_list"] = files_list
+            files_end = time.time()
+            logger.debug(f"Time taken for file key processing: {files_end - files_start:.4f}s")
+        
+        end = time.time()
+        logger.debug(f"Total time in get_prompts: {end - start:.4f}s")
         return prompts
 
 
-if __name__ == "__main__":
-    import doctest
+def _process_prompt(args):
+    """Helper function to process a single prompt list with its replacements."""
+    prompt_list, replacements = args
+    return prompt_list.reduce()
+
 
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+if __name__ == '__main__':
+    freeze_support()

edsl/agents/QuestionInstructionPromptBuilder.py

@@ -1,5 +1,6 @@
 from typing import Dict, List, Set
 from warnings import warn
+import logging
 from edsl.prompts.Prompt import Prompt
 
 from edsl.agents.QuestionTemplateReplacementsBuilder import (
@@ -23,12 +24,44 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Prompt: The fully rendered question instructions
         """
+        import time
+        
+        start = time.time()
+        
+        # Create base prompt
+        base_start = time.time()
         base_prompt = self._create_base_prompt()
+        base_end = time.time()
+        logging.debug(f"Time for base prompt: {base_end - base_start}")
+        
+        # Enrich with options
+        enrich_start = time.time()
         enriched_prompt = self._enrich_with_question_options(base_prompt)
+        enrich_end = time.time()
+        logging.debug(f"Time for enriching with options: {enrich_end - enrich_start}")
+        
+        # Render prompt
+        render_start = time.time()
         rendered_prompt = self._render_prompt(enriched_prompt)
+        render_end = time.time()
+        logging.debug(f"Time for rendering prompt: {render_end - render_start}")
+        
+        # Validate template variables
+        validate_start = time.time()
         self._validate_template_variables(rendered_prompt)
-
-        return self._append_survey_instructions(rendered_prompt)
+        validate_end = time.time()
+        logging.debug(f"Time for template validation: {validate_end - validate_start}")
+        
+        # Append survey instructions
+        append_start = time.time()
+        final_prompt = self._append_survey_instructions(rendered_prompt)
+        append_end = time.time()
+        logging.debug(f"Time for appending survey instructions: {append_end - append_start}")
+        
+        end = time.time()
+        logging.debug(f"Total time in build_question_instructions: {end - start}")
+        
+        return final_prompt
 
     def _create_base_prompt(self) -> Dict:
         """Creates the initial prompt with basic question data.
@@ -50,14 +83,25 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Dict: Enriched prompt data
         """
+        import time
+        
+        start = time.time()
+        
         if "question_options" in prompt_data["data"]:
             from edsl.agents.question_option_processor import QuestionOptionProcessor
-
+            
+            processor_start = time.time()
             question_options = QuestionOptionProcessor(
                 self.prompt_constructor
             ).get_question_options(question_data=prompt_data["data"])
-
+            processor_end = time.time()
+            logging.debug(f"Time to process question options: {processor_end - processor_start}")
+            
             prompt_data["data"]["question_options"] = question_options
+            
+        end = time.time()
+        logging.debug(f"Total time in _enrich_with_question_options: {end - start}")
+        
         return prompt_data
 
     def _render_prompt(self, prompt_data: Dict) -> Prompt:
@@ -69,11 +113,28 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Prompt: Rendered instructions
         """
-
+        import time
+        
+        start = time.time()
+        
+        # Build replacement dict
+        dict_start = time.time()
         replacement_dict = QTRB(self.prompt_constructor).build_replacement_dict(
             prompt_data["data"]
         )
-        return prompt_data["prompt"].render(replacement_dict)
+        dict_end = time.time()
+        logging.debug(f"Time to build replacement dict: {dict_end - dict_start}")
+        
+        # Render with dict
+        render_start = time.time()
+        result = prompt_data["prompt"].render(replacement_dict)
+        render_end = time.time()
+        logging.debug(f"Time to render with dict: {render_end - render_start}")
+        
+        end = time.time()
+        logging.debug(f"Total time in _render_prompt: {end - start}")
+        
+        return result
 
     def _validate_template_variables(self, rendered_prompt: Prompt) -> None:
         """Validates that all template variables have been properly replaced.
@@ -101,9 +162,7 @@ class QuestionInstructionPromptBuilder:
         """
         for question_name in self.survey.question_names:
             if question_name in undefined_vars:
-                print(
-                    f"Question name found in undefined_template_variables: {question_name}"
-                )
+                logging.warning(f"Question name found in undefined_template_variables: {question_name}")
 
     def _append_survey_instructions(self, rendered_prompt: Prompt) -> Prompt:
         """Appends any relevant survey instructions to the rendered prompt.

edsl/agents/QuestionTemplateReplacementsBuilder.py

@@ -1,4 +1,4 @@
-from jinja2 import Environment, meta
+from jinja2 import Environment, meta, TemplateSyntaxError
 from typing import Any, Set, TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -29,7 +29,12 @@ class QuestionTemplateReplacementsBuilder:
         Set[str]: A set of variable names found in the template
         """
         env = Environment()
-        ast = env.parse(template_str)
+        try:
+            ast = env.parse(template_str)
+        except TemplateSyntaxError:
+            print(f"Error parsing template: {template_str}")
+            raise
+
         return meta.find_undeclared_variables(ast)
 
     @staticmethod

edsl/agents/prompt_helpers.py

@@ -124,6 +124,6 @@ class PromptPlan:
         """Get both prompts for the LLM call."""
         prompts = self.arrange_components(**kwargs)
         return {
-            "user_prompt": prompts["user_prompt"].reduce(),
-            "system_prompt": prompts["system_prompt"].reduce(),
+            "user_prompt": Prompt("".join(str(p) for p in prompts["user_prompt"])),
+            "system_prompt": Prompt("".join(str(p) for p in prompts["system_prompt"])),
         }

edsl/coop/coop.py

@@ -14,7 +14,11 @@ from edsl.data.CacheEntry import CacheEntry
 from edsl.jobs.Jobs import Jobs
 from edsl.surveys.Survey import Survey
 
-from edsl.exceptions.coop import CoopNoUUIDError, CoopServerResponseError
+from edsl.exceptions.coop import (
+    CoopInvalidURLError,
+    CoopNoUUIDError,
+    CoopServerResponseError,
+)
 from edsl.coop.utils import (
     EDSLObject,
     ObjectRegistry,
@@ -285,17 +289,46 @@ class Coop(CoopFunctionsMixin):
         if value is None:
             return "null"
 
-    def _resolve_uuid(
+    def _resolve_uuid_or_alias(
         self, uuid: Union[str, UUID] = None, url: str = None
-    ) -> Union[str, UUID]:
+    ) -> tuple[Optional[str], Optional[str], Optional[str]]:
         """
-        Resolve the uuid from a uuid or a url.
+        Resolve the uuid or alias information from a uuid or a url.
+        Returns a tuple of (uuid, owner_username, alias)
+        - For content/<uuid> URLs: returns (uuid, None, None)
+        - For content/<username>/<alias> URLs: returns (None, username, alias)
         """
         if not url and not uuid:
             raise CoopNoUUIDError("No uuid or url provided for the object.")
+
         if not uuid and url:
-            uuid = url.split("/")[-1]
-        return uuid
+            parts = (
+                url.replace("http://", "")
+                .replace("https://", "")
+                .rstrip("/")
+                .split("/")
+            )
+
+            # Remove domain
+            parts = parts[1:]
+
+            if len(parts) < 2 or parts[0] != "content":
+                raise CoopInvalidURLError(
+                    f"Invalid URL format. The URL must end with /content/<uuid> or /content/<username>/<alias>: {url}"
+                )
+
+            if len(parts) == 2:
+                obj_uuid = parts[1]
+                return obj_uuid, None, None
+            elif len(parts) == 3:
+                username, alias = parts[1], parts[2]
+                return None, username, alias
+            else:
+                raise CoopInvalidURLError(
+                    f"Invalid URL format. The URL must end with /content/<uuid> or /content/<username>/<alias>: {url}"
+                )
+
+        return str(uuid), None, None
 
     @property
     def edsl_settings(self) -> dict:
@@ -361,22 +394,31 @@ class Coop(CoopFunctionsMixin):
         expected_object_type: Optional[ObjectType] = None,
     ) -> EDSLObject:
         """
-        Retrieve an EDSL object by its uuid or its url.
+        Retrieve an EDSL object by its uuid/url or by owner username and alias.
         - If the object's visibility is private, the user must be the owner.
         - Optionally, check if the retrieved object is of a certain type.
 
         :param uuid: the uuid of the object either in str or UUID format.
-        :param url: the url of the object.
+        :param url: the url of the object (can be content/uuid or content/username/alias format).
         :param expected_object_type: the expected type of the object.
 
         :return: the object instance.
         """
-        uuid = self._resolve_uuid(uuid, url)
-        response = self._send_server_request(
-            uri=f"api/v0/object",
-            method="GET",
-            params={"uuid": uuid},
-        )
+        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(uuid, url)
+
+        if obj_uuid:
+            response = self._send_server_request(
+                uri=f"api/v0/object",
+                method="GET",
+                params={"uuid": obj_uuid},
+            )
+        else:
+            response = self._send_server_request(
+                uri=f"api/v0/object/alias",
+                method="GET",
+                params={"owner_username": owner_username, "alias": alias},
+            )
+
         self._resolve_server_response(response)
         json_string = response.json().get("json_string")
         object_type = response.json().get("object_type")
@@ -414,12 +456,13 @@ class Coop(CoopFunctionsMixin):
         """
         Delete an object from the server.
         """
-        uuid = self._resolve_uuid(uuid, url)
+        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
         response = self._send_server_request(
             uri=f"api/v0/object",
             method="DELETE",
-            params={"uuid": uuid},
+            params={"uuid": obj_uuid},
         )
+
         self._resolve_server_response(response)
         return response.json()
 
@@ -438,11 +481,11 @@ class Coop(CoopFunctionsMixin):
         """
         if description is None and visibility is None and value is None:
             raise Exception("Nothing to patch.")
-        uuid = self._resolve_uuid(uuid, url)
+        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
         response = self._send_server_request(
             uri=f"api/v0/object",
             method="PATCH",
-            params={"uuid": uuid},
+            params={"uuid": obj_uuid},
             payload={
                 "description": description,
                 "alias": alias,
@@ -549,6 +592,7 @@ class Coop(CoopFunctionsMixin):
     def remote_cache_get(
         self,
         exclude_keys: Optional[list[str]] = None,
+        select_keys: Optional[list[str]] = None,
     ) -> list[CacheEntry]:
         """
         Get all remote cache entries.
@@ -560,10 +604,12 @@ class Coop(CoopFunctionsMixin):
         """
         if exclude_keys is None:
             exclude_keys = []
+        if select_keys is None:
+            select_keys = []
         response = self._send_server_request(
             uri="api/v0/remote-cache/get-many",
             method="POST",
-            payload={"keys": exclude_keys},
+            payload={"keys": exclude_keys, "selected_keys": select_keys},
             timeout=40,
         )
         self._resolve_server_response(response)
@@ -894,6 +940,38 @@ class Coop(CoopFunctionsMixin):
         data = response.json()
         return ServiceToModelsMapping(data)
 
+    def fetch_working_models(self) -> list[dict]:
+        """
+        Fetch a list of working models from Coop.
+
+        Example output:
+
+        [
+            {
+                "service": "openai",
+                "model": "gpt-4o",
+                "works_with_text": True,
+                "works_with_images": True,
+                "usd_per_1M_input_tokens": 2.5,
+                "usd_per_1M_output_tokens": 10.0,
+            }
+        ]
+        """
+        response = self._send_server_request(uri="api/v0/working-models", method="GET")
+        self._resolve_server_response(response)
+        data = response.json()
+        return [
+            {
+                "service": record.get("service"),
+                "model": record.get("model"),
+                "works_with_text": record.get("works_with_text"),
+                "works_with_images": record.get("works_with_images"),
+                "usd_per_1M_input_tokens": record.get("input_price_per_1M_tokens"),
+                "usd_per_1M_output_tokens": record.get("output_price_per_1M_tokens"),
+            }
+            for record in data
+        ]
+
     def fetch_rate_limit_config_vars(self) -> dict:
         """
         Fetch a dict of rate limit config vars from Coop.

edsl/enums.py

@@ -66,6 +66,7 @@ class InferenceServiceType(EnumWithChecks):
     MISTRAL = "mistral"
     TOGETHER = "together"
     PERPLEXITY = "perplexity"
+    DEEPSEEK = "deepseek"
 
 
 # unavoidable violation of the DRY principle but it is necessary
@@ -84,6 +85,7 @@ InferenceServiceLiteral = Literal[
     "mistral",
     "together",
     "perplexity",
+    "deepseek",
 ]
 
 available_models_urls = {
@@ -95,7 +97,6 @@ available_models_urls = {
 
 
 service_to_api_keyname = {
-    InferenceServiceType.BEDROCK.value: "TBD",
     InferenceServiceType.DEEP_INFRA.value: "DEEP_INFRA_API_KEY",
     InferenceServiceType.REPLICATE.value: "TBD",
     InferenceServiceType.OPENAI.value: "OPENAI_API_KEY",
@@ -107,6 +108,7 @@ service_to_api_keyname = {
     InferenceServiceType.MISTRAL.value: "MISTRAL_API_KEY",
     InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
     InferenceServiceType.PERPLEXITY.value: "PERPLEXITY_API_KEY",
+    InferenceServiceType.DEEPSEEK.value: "DEEPSEEK_API_KEY"
 }
 
 

edsl/exceptions/coop.py

@@ -2,6 +2,10 @@ class CoopErrors(Exception):
     pass
 
 
+class CoopInvalidURLError(CoopErrors):
+    pass
+
+
 class CoopNoUUIDError(CoopErrors):
     pass
 

edsl/exceptions/jobs.py

@@ -10,15 +10,7 @@ class JobsRunError(JobsErrors):
 
 
 class MissingRemoteInferenceError(JobsErrors):
-    def __init__(self):
-        message = dedent(
-            """\\
-                        You are trying to run the job remotely, but you have not set the EXPECTED_PARROT_INFERENCE_URL environment variable.
-                        This remote running service is not quite ready yet! 
-                        But please see https://docs.expectedparrot.com/en/latest/coop.html for what we are working on.
-                        """
-        )
-        super().__init__(message)
+    pass
 
 
 class InterviewError(Exception):

edsl/exceptions/language_models.py

@@ -34,11 +34,15 @@ class LanguageModelNotFound(LanguageModelExceptions):
         msg = dedent(
             f"""\
             Model {model_name} not found.
-            To create an instance, you can do: 
-            >>> m = Model('gpt-4-1106-preview', temperature=0.5, ...)
+            To create an instance of this model, pass the model name to a `Model` object.
+            You can optionally pass additional parameters to the model, e.g.: 
+            >>> m = Model('gpt-4-1106-preview', temperature=0.5)
             
-            To get the default model, you can leave out the model name. 
-            To see the available models, you can do:
+            To use the default model, simply run your job without specifying a model.
+            To check the default model, run the following code:
+            >>> Model()
+
+            To see information about all available models, run the following code:
             >>> Model.available()
 
             See https://docs.expectedparrot.com/en/latest/language_models.html#available-models for more details.

edsl/exceptions/questions.py

@@ -16,7 +16,8 @@ class QuestionErrors(Exception):
 class QuestionAnswerValidationError(QuestionErrors):
     documentation = "https://docs.expectedparrot.com/en/latest/exceptions.html"
 
-    explanation = """This when the answer coming from the Language Model does not conform to the expectation for that question type.
+    explanation = """
+    This can occur when the answer coming from the Language Model does not conform to the expectations for the question type.
     For example, if the question is a multiple choice question, the answer should be drawn from the list of options provided.
     """
 
@@ -52,28 +53,24 @@ class QuestionAnswerValidationError(QuestionErrors):
 
     def to_html_dict(self):
         return {
-            "error_type": ("Name of the exception", "p", "/p", self.__class__.__name__),
-            "explaination": ("Explanation", "p", "/p", self.explanation),
-            "edsl answer": (
-                "What model returned",
+            "Exception type": ("p", "/p", self.__class__.__name__),
+            "Explanation": ("p", "/p", self.explanation),
+            "EDSL response": (
                 "pre",
                 "/pre",
                 json.dumps(self.data, indent=2),
             ),
-            "validating_model": (
-                "Pydantic model for answers",
+            "Validating model": (
                 "pre",
                 "/pre",
                 json.dumps(self.model.model_json_schema(), indent=2),
             ),
-            "error_message": (
-                "Error message Pydantic returned",
+            "Error message": (
                 "p",
                 "/p",
                 self.message,
             ),
-            "documentation_url": (
-                "URL to EDSL docs",
+            "Documentation": (
                 f"a href='{self.documentation}'",
                 "/a",
                 self.documentation,