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

edsl/questions/HTMLQuestion.py

@@ -1,103 +0,0 @@
-from typing import Optional
-from edsl.prompts.Prompt import Prompt
-
-
-class HTMLQuestion:
-    def __init__(self, question):
-        self.question = question
-
-    def html(
-        self,
-        scenario: Optional[dict] = None,
-        agent: Optional[dict] = {},
-        answers: Optional[dict] = None,
-        include_question_name: bool = False,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        iframe=False,
-    ):
-        """Return the question in HTML format."""
-        from jinja2 import Template
-
-        if scenario is None:
-            scenario = {}
-
-        prior_answers_dict = {}
-
-        if isinstance(answers, dict):
-            for key, value in answers.items():
-                if not key.endswith("_comment") and not key.endswith(
-                    "_generated_tokens"
-                ):
-                    prior_answers_dict[key] = {"answer": value}
-
-        base_template = """
-        <div id="{{ question_name }}" class="survey_question" data-type="{{ question_type }}">
-            {% if include_question_name %}
-            <p>question_name: {{ question_name }}</p>
-            {% endif %}
-            <p class="question_text">{{ question_text }}</p>
-            {{ question_content }}
-        </div>
-        """
-        if not hasattr(self.question, "question_type"):
-            self.question.question_type = "unknown"
-
-        if hasattr(self.question, "question_html_content"):
-            question_content = self.question.question_html_content
-        else:
-            question_content = Template("")
-
-        base_template = Template(base_template)
-
-        context = {
-            "scenario": scenario,
-            "agent": agent,
-        } | prior_answers_dict
-
-        # Render the question text
-        try:
-            question_text = Template(self.question.question_text).render(context)
-        except Exception as e:
-            print(
-                f"Error rendering question: question_text = {self.question.question_text}, error = {e}"
-            )
-            question_text = self.question.question_text
-
-        try:
-            question_content = Template(question_content).render(context)
-        except Exception as e:
-            print(
-                f"Error rendering question: question_content = {question_content}, error = {e}"
-            )
-            question_content = question_content
-
-        try:
-            params = {
-                "question_name": self.question.question_name,
-                "question_text": question_text,
-                "question_type": self.question.question_type,
-                "question_content": question_content,
-                "include_question_name": include_question_name,
-            }
-        except Exception as e:
-            raise ValueError(
-                f"Error rendering question: params = {params}, error = {e}"
-            )
-        rendered_html = base_template.render(**params)
-
-        if iframe:
-            import html
-            from IPython.display import display, HTML
-
-            height = height or 200
-            width = width or 600
-            escaped_output = html.escape(rendered_html)
-            # escaped_output = rendered_html
-            iframe = f""""
-            <iframe srcdoc="{ escaped_output }" style="width: {width}px; height: {height}px;"></iframe>
-            """
-            display(HTML(iframe))
-            return None
-
-        return rendered_html

edsl/questions/LoopProcessor.py

@@ -1,149 +0,0 @@
-from typing import List, Any, Dict, Union
-from jinja2 import Environment
-from edsl.questions.QuestionBase import QuestionBase
-from edsl import ScenarioList
-
-
-class LoopProcessor:
-    def __init__(self, question: QuestionBase):
-        self.question = question
-        self.env = Environment()
-
-    def process_templates(self, scenario_list: ScenarioList) -> List[QuestionBase]:
-        """Process templates for each scenario and return list of modified questions.
-
-        Args:
-            scenario_list: List of scenarios to process templates against
-
-        Returns:
-            List of QuestionBase objects with rendered templates
-        """
-        questions = []
-        starting_name = self.question.question_name
-
-        for index, scenario in enumerate(scenario_list):
-            question_data = self.question.to_dict().copy()
-            processed_data = self._process_data(question_data, scenario)
-
-            if processed_data["question_name"] == starting_name:
-                processed_data["question_name"] += f"_{index}"
-
-            questions.append(QuestionBase.from_dict(processed_data))
-
-        return questions
-
-    def _process_data(
-        self, data: Dict[str, Any], scenario: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Process all data fields according to their type.
-
-        Args:
-            data: Dictionary of question data
-            scenario: Current scenario to render templates against
-
-        Returns:
-            Processed dictionary with rendered templates
-        """
-        processed = {}
-
-        for key, value in [(k, v) for k, v in data.items() if v is not None]:
-            processed[key] = self._process_value(key, value, scenario)
-
-        return processed
-
-    def _process_value(self, key: str, value: Any, scenario: Dict[str, Any]) -> Any:
-        """Process a single value according to its type.
-
-        Args:
-            key: Dictionary key
-            value: Value to process
-            scenario: Current scenario
-
-        Returns:
-            Processed value
-        """
-        if key == "question_options" and isinstance(value, str):
-            return value
-
-        if key == "option_labels":
-            import json
-
-            return (
-                eval(self._render_template(value, scenario))
-                if isinstance(value, str)
-                else value
-            )
-
-        if isinstance(value, str):
-            return self._render_template(value, scenario)
-
-        if isinstance(value, list):
-            return self._process_list(value, scenario)
-
-        if isinstance(value, dict):
-            return self._process_dict(value, scenario)
-
-        if isinstance(value, (int, float)):
-            return value
-
-        raise ValueError(f"Unexpected value type: {type(value)} for key '{key}'")
-
-    def _render_template(self, template: str, scenario: Dict[str, Any]) -> str:
-        """Render a single template string.
-
-        Args:
-            template: Template string to render
-            scenario: Current scenario
-
-        Returns:
-            Rendered template string
-        """
-        return self.env.from_string(template).render(scenario)
-
-    def _process_list(self, items: List[Any], scenario: Dict[str, Any]) -> List[Any]:
-        """Process all items in a list.
-
-        Args:
-            items: List of items to process
-            scenario: Current scenario
-
-        Returns:
-            List of processed items
-        """
-        return [
-            self._render_template(item, scenario) if isinstance(item, str) else item
-            for item in items
-        ]
-
-    def _process_dict(
-        self, data: Dict[str, Any], scenario: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Process all keys and values in a dictionary.
-
-        Args:
-            data: Dictionary to process
-            scenario: Current scenario
-
-        Returns:
-            Dictionary with processed keys and values
-        """
-        return {
-            (self._render_template(k, scenario) if isinstance(k, str) else k): (
-                self._render_template(v, scenario) if isinstance(v, str) else v
-            )
-            for k, v in data.items()
-        }
-
-
-# Usage example:
-"""
-from edsl import QuestionFreeText, ScenarioList
-
-question = QuestionFreeText(
-    question_text="What are your thoughts on: {{subject}}?",
-    question_name="base_{{subject}}"
-)
-processor = TemplateProcessor(question)
-scenarios = ScenarioList.from_list("subject", ["Math", "Economics", "Chemistry"])
-processed_questions = processor.process_templates(scenarios)
-"""

edsl/questions/QuestionMatrix.py

@@ -1,265 +0,0 @@
-from __future__ import annotations
-from typing import Union, Optional, Dict, List, Any
-
-from pydantic import BaseModel, Field, field_validator
-from jinja2 import Template
-import random
-from edsl.questions.QuestionBase import QuestionBase
-from edsl.questions.descriptors import (
-    QuestionOptionsDescriptor,
-    OptionLabelDescriptor,
-    QuestionTextDescriptor,
-)
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-from edsl.questions.decorators import inject_exception
-from edsl.exceptions.questions import (
-    QuestionAnswerValidationError,
-    QuestionCreationValidationError,
-)
-
-
-def create_matrix_response(
-    question_items: List[str],
-    question_options: List[Union[int, str, float]],
-    permissive: bool = False,
-):
-    """Create a response model for matrix questions.
-
-    The response model validates that:
-    1. All question items are answered
-    2. Each answer is from the allowed options
-    """
-
-    if permissive:
-
-        class MatrixResponse(BaseModel):
-            answer: Dict[str, Any]
-            comment: Optional[str] = None
-            generated_tokens: Optional[Any] = None
-
-    else:
-
-        class MatrixResponse(BaseModel):
-            answer: Dict[str, Union[int, str, float]] = Field(
-                ..., description="Mapping of items to selected options"
-            )
-            comment: Optional[str] = None
-            generated_tokens: Optional[Any] = None
-
-            @field_validator("answer")
-            def validate_answer(cls, v, values, **kwargs):
-                # Check that all items have responses
-                if not all(item in v for item in question_items):
-                    missing = set(question_items) - set(v.keys())
-                    raise ValueError(f"Missing responses for items: {missing}")
-
-                # Check that all responses are valid options
-                if not all(answer in question_options for answer in v.values()):
-                    invalid = [ans for ans in v.values() if ans not in question_options]
-                    raise ValueError(f"Invalid options selected: {invalid}")
-                return v
-
-    return MatrixResponse
-
-
-class MatrixResponseValidator(ResponseValidatorABC):
-    required_params = ["question_items", "question_options", "permissive"]
-
-    valid_examples = [
-        (
-            {"answer": {"Item1": 1, "Item2": 2}},
-            {
-                "question_items": ["Item1", "Item2"],
-                "question_options": [1, 2, 3],
-            },
-        )
-    ]
-
-    invalid_examples = [
-        (
-            {"answer": {"Item1": 1}},
-            {
-                "question_items": ["Item1", "Item2"],
-                "question_options": [1, 2, 3],
-            },
-            "Missing responses for some items",
-        ),
-        (
-            {"answer": {"Item1": 4, "Item2": 5}},
-            {
-                "question_items": ["Item1", "Item2"],
-                "question_options": [1, 2, 3],
-            },
-            "Invalid options selected",
-        ),
-    ]
-
-    def fix(self, response, verbose=False):
-        if verbose:
-            print(f"Fixing matrix response: {response}")
-
-        # If we have generated tokens, try to parse them
-        if "generated_tokens" in response:
-            try:
-                import json
-
-                fixed = json.loads(response["generated_tokens"])
-                if isinstance(fixed, dict):
-                    # Map numeric keys to question items
-                    mapped_answer = {}
-                    for idx, item in enumerate(self.question_items):
-                        if str(idx) in fixed:
-                            mapped_answer[item] = fixed[str(idx)]
-                    if (
-                        mapped_answer
-                    ):  # Only return if we successfully mapped some answers
-                        return {"answer": mapped_answer}
-            except:
-                pass
-
-        # If answer uses numeric keys, map them to question items
-        if "answer" in response and isinstance(response["answer"], dict):
-            if all(str(key).isdigit() for key in response["answer"].keys()):
-                mapped_answer = {}
-                for idx, item in enumerate(self.question_items):
-                    if str(idx) in response["answer"]:
-                        mapped_answer[item] = response["answer"][str(idx)]
-                if mapped_answer:  # Only update if we successfully mapped some answers
-                    response["answer"] = mapped_answer
-
-        return response
-
-
-class QuestionMatrix(QuestionBase):
-    """A question that presents a matrix/grid where multiple items are rated using the same scale."""
-
-    question_type = "matrix"
-    question_text: str = QuestionTextDescriptor()
-    question_items: List[str] = QuestionOptionsDescriptor()
-    question_options: List[Union[int, str, float]] = QuestionOptionsDescriptor()
-    option_labels: Optional[Dict[Union[int, str, float], str]] = OptionLabelDescriptor()
-
-    _response_model = None
-    response_validator_class = MatrixResponseValidator
-
-    def __init__(
-        self,
-        question_name: str,
-        question_text: str,
-        question_items: List[str],
-        question_options: List[Union[int, str, float]],
-        option_labels: Optional[Dict[Union[int, str, float], str]] = None,
-        include_comment: bool = True,
-        answering_instructions: Optional[str] = None,
-        question_presentation: Optional[str] = None,
-        permissive: bool = False,
-    ):
-        """Initialize a matrix question.
-
-        Args:
-            question_name: The name of the question
-            question_text: The text of the question
-            question_items: List of items to be rated
-            question_options: List of rating options
-            option_labels: Optional mapping of options to their labels
-            include_comment: Whether to include a comment field
-            answering_instructions: Optional custom instructions
-            question_presentation: Optional custom presentation
-            permissive: Whether to strictly validate responses
-        """
-        self.question_name = question_name
-
-        try:
-            self.question_text = question_text
-        except Exception as e:
-            raise QuestionCreationValidationError(
-                "question_text cannot be empty or too short!"
-            ) from e
-
-        self.question_items = question_items
-        self.question_options = question_options
-        self.option_labels = option_labels or {}
-
-        self.include_comment = include_comment
-        self.answering_instructions = answering_instructions
-        self.question_presentation = question_presentation
-        self.permissive = permissive
-
-    def create_response_model(self):
-        return create_matrix_response(
-            self.question_items, self.question_options, self.permissive
-        )
-
-    @property
-    def question_html_content(self) -> str:
-        """Generate HTML representation of the matrix question."""
-        template = Template(
-            """
-        <table class="matrix-question">
-            <tr>
-                <th></th>
-                {% for option in question_options %}
-                <th>
-                    {{ option }}
-                    {% if option in option_labels %}
-                    <br>
-                    <small>{{ option_labels[option] }}</small>
-                    {% endif %}
-                </th>
-                {% endfor %}
-            </tr>
-            {% for item in question_items %}
-            <tr>
-                <td>{{ item }}</td>
-                {% for option in question_options %}
-                <td>
-                    <input type="radio" 
-                           name="{{ question_name }}_{{ item }}" 
-                           value="{{ option }}"
-                           id="{{ question_name }}_{{ item }}_{{ option }}">
-                </td>
-                {% endfor %}
-            </tr>
-            {% endfor %}
-        </table>
-        """
-        )
-
-        return template.render(
-            question_name=self.question_name,
-            question_items=self.question_items,
-            question_options=self.question_options,
-            option_labels=self.option_labels,
-        )
-
-    @classmethod
-    @inject_exception
-    def example(cls) -> QuestionMatrix:
-        """Return an example matrix question."""
-        return cls(
-            question_name="child_happiness",
-            question_text="How happy would you be with different numbers of children?",
-            question_items=[
-                "No children",
-                "1 child",
-                "2 children",
-                "3 or more children",
-            ],
-            question_options=[1, 2, 3, 4, 5],
-            option_labels={1: "Very sad", 3: "Neutral", 5: "Extremely happy"},
-        )
-
-    def _simulate_answer(self) -> dict:
-        """Simulate a random valid answer."""
-        return {
-            "answer": {
-                item: random.choice(self.question_options)
-                for item in self.question_items
-            }
-        }
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/ResponseValidatorFactory.py

@@ -1,28 +0,0 @@
-class ResponseValidatorFactory:
-    def __init__(self, question):
-        self.question = question
-
-    @property
-    def response_model(self) -> type["BaseModel"]:
-        if self.question._response_model is not None:
-            return self.question._response_model
-        else:
-            return self.question.create_response_model()
-
-    @property
-    def response_validator(self) -> "ResponseValidatorBase":
-        """Return the response validator."""
-        params = (
-            {
-                "response_model": self.question.response_model,
-            }
-            | {k: getattr(self.question, k) for k in self.validator_parameters}
-            | {"exception_to_throw": getattr(self.question, "exception_to_throw", None)}
-            | {"override_answer": getattr(self.question, "override_answer", None)}
-        )
-        return self.question.response_validator_class(**params)
-
-    @property
-    def validator_parameters(self) -> list[str]:
-        """Return the parameters required for the response validator."""
-        return self.question.response_validator_class.required_params

edsl/questions/templates/matrix/__init__.py

@@ -1 +0,0 @@
-

edsl/questions/templates/matrix/answering_instructions.jinja

@@ -1,5 +0,0 @@
-Please respond with a dictionary mapping row codes to column codes. E.g., {"0": 1, "1": 3}
-
-{% if include_comment %}
-After the answer, you can put a comment explaining your choices on the next line.
-{% endif %} 

edsl/questions/templates/matrix/question_presentation.jinja

@@ -1,20 +0,0 @@
-{{question_text}}
-
-Rows:
-    {% for item in question_items %}
-{{ loop.index0 }}: {{item}}
-    {% endfor %}
-
-Columns:
-    {% for option in question_options %}
-{{ loop.index0 }}: {{option}}
-        {%- if option in option_labels %}
- ({{option_labels[option]}})
-        {%- endif %}
-    {% endfor %}
-
-
-Select one column option for each row.
-{% if required %}
-All rows require a response.
-{% endif %} 

edsl/results/MarkdownToDocx.py

@@ -1,122 +0,0 @@
-from typing import Optional
-import subprocess
-import os
-from pathlib import Path
-import tempfile
-
-
-class MarkdownToDocx:
-    def __init__(self, markdown_content: str, filename: Optional[str] = None):
-        """
-        Initialize the converter with markdown content.
-
-        Args:
-            markdown_content (str): The markdown content to be converted
-        """
-        self.markdown_content = markdown_content
-        self.filename = filename
-        self._check_pandoc()
-
-    def _check_pandoc(self):
-        """Check if pandoc is installed and accessible."""
-        try:
-            subprocess.run(["pandoc", "--version"], capture_output=True, check=True)
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            raise RuntimeError(
-                "Pandoc is not installed or not found in PATH. "
-                "Please install pandoc before using this converter."
-            )
-
-    def convert(self, output_path: str, **options) -> bool:
-        """
-        Convert the markdown content to DOCX.
-
-        Args:
-            output_path (str): Path where the DOCX should be saved
-            **options: Additional conversion options
-                reference_doc (str): Path to reference docx for styling
-                toc (bool): Include table of contents (default: False)
-                number_sections (bool): Number sections (default: False)
-                highlight_style (str): Code highlighting style (default: "tango")
-
-        Returns:
-            bool: True if conversion was successful, False otherwise
-        """
-        # Ensure output directory exists
-        output_path = Path(output_path)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Build pandoc command
-        cmd = ["pandoc", "-f", "markdown", "-t", "docx", "-o", str(output_path)]
-
-        # Add reference doc if provided
-        if "reference_doc" in options:
-            ref_doc = Path(options["reference_doc"])
-            if ref_doc.exists():
-                cmd.extend(["--reference-doc", str(ref_doc)])
-            else:
-                print(f"Warning: Reference document {ref_doc} not found")
-
-        # Add optional parameters
-        if options.get("toc", False):
-            cmd.append("--toc")
-
-        if options.get("number_sections", False):
-            cmd.append("--number-sections")
-
-        if "highlight_style" in options:
-            cmd.extend(["--highlight-style", options["highlight_style"]])
-
-        try:
-            # Run pandoc command
-            result = subprocess.run(
-                cmd,
-                input=self.markdown_content,
-                text=True,
-                capture_output=True,
-                check=True,
-            )
-            return True
-        except subprocess.CalledProcessError as e:
-            print(f"Error converting markdown to DOCX: {e.stderr}")
-            return False
-
-    def preview(self) -> str:
-        """
-        Generate a temporary DOCX and return its path.
-
-        Returns:
-            str: Path to the temporary DOCX file
-        """
-        temp_dir = tempfile.mkdtemp()
-        if self.filename:
-            temp_docx = os.path.join(temp_dir, self.filename)
-        else:
-            temp_docx = os.path.join(temp_dir, "preview.docx")
-
-        if self.convert(temp_docx):
-            from edsl.scenarios.FileStore import FileStore
-
-            return FileStore(path=temp_docx)
-
-        return None
-
-    def create_template(self, output_path: str) -> bool:
-        """
-        Create a reference DOCX template that can be modified for styling.
-
-        Args:
-            output_path (str): Path where the template should be saved
-
-        Returns:
-            bool: True if template was created successfully, False otherwise
-        """
-        try:
-            cmd = ["pandoc", "--print-default-data-file", "reference.docx"]
-
-            with open(output_path, "wb") as f:
-                result = subprocess.run(cmd, stdout=f, check=True)
-            return True
-        except subprocess.CalledProcessError as e:
-            print(f"Error creating template: {e.stderr}")
-            return False