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

edsl/surveys/SurveyCSS.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.utilities.remove_edsl_version import remove_edsl_version
 
 
 class CSSRuleMeta(type):
@@ -64,14 +64,21 @@ class CSSRule(metaclass=CSSRuleMeta):
     def __repr__(self) -> str:
         return f"CSSRule(select = {self.selector}, properties = {self.properties})"
 
-    @add_edsl_version
-    def to_dict(self) -> dict:
+    def to_dict(self, add_esl_version: bool = True) -> dict:
         """
         >>> rule = CSSRule("survey_container", {"width": "80%", "margin": "0 auto"})
         >>> rule.to_dict()
-        {'selector': 'survey_container', 'properties': {'width': '80%', 'margin': '0 auto'}, 'edsl_version': '...', 'edsl_class_name': 'CSSRule'}
+        {'selector': 'survey_container', 'properties': {'width': '80%', 'margin': '0 auto'}, 'edsl_version': '...', 'edsl_class_name': '...'}
         """
-        return {"selector": self.selector, "properties": self.properties}
+        d = {"selector": self.selector, "properties": self.properties}
+
+        if add_esl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = self.__class__.__name__
+
+        return d
 
     @classmethod
     @remove_edsl_version
@@ -218,14 +225,19 @@ class SurveyCSS:
             css_lines.append(rule.generate_rule())
         return "\n".join(css_lines)
 
-    @add_edsl_version
-    def to_dict(self) -> dict:
+    def to_dict(self, add_edsl_version: bool = True) -> dict:
         """
         >>> css = SurveyCSS(rules = []).update_style("survey_container", "width", "100%")
         >>> css.to_dict()
         {'rules': [{'selector': 'survey_container', 'properties': {'width': '100%'}, 'edsl_version': '...', 'edsl_class_name': 'CSSRule'}], 'edsl_version': '...', 'edsl_class_name': 'SurveyCSS'}
         """
-        return {"rules": [rule.to_dict() for rule in self.rules.values()]}
+        d = {"rules": [rule.to_dict() for rule in self.rules.values()]}
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = self.__class__.__name__
+        return d
 
     def __repr__(self) -> str:
         return f"SurveyCSS(rules = {[rule for rule in self.rules.values()]})"

edsl/surveys/{SurveyFlowVisualizationMixin.py → SurveyFlowVisualization.py}

@@ -1,14 +1,16 @@
 """A mixin for visualizing the flow of a survey with parameter nodes."""
 
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 from edsl.surveys.base import RulePriority, EndOfSurvey
 import tempfile
-import os
 
 
-class SurveyFlowVisualizationMixin:
+class SurveyFlowVisualization:
     """A mixin for visualizing the flow of a survey with parameter visualization."""
 
+    def __init__(self, survey: "Survey"):
+        self.survey = survey
+
     def show_flow(self, filename: Optional[str] = None):
         """Create an image showing the flow of users through the survey and question parameters."""
         # Create a graph object
@@ -22,7 +24,7 @@ class SurveyFlowVisualizationMixin:
         answer_refs = set()  # Track answer references between questions
 
         # First pass: collect parameters and their question associations
-        for index, question in enumerate(self.questions):
+        for index, question in enumerate(self.survey.questions):
             # Add the main question node
             question_node = pydot.Node(
                 f"Q{index}", label=f"{question.question_name}", shape="ellipse"
@@ -69,7 +71,7 @@ class SurveyFlowVisualizationMixin:
             # Find the source question index by name
             source_q_index = next(
                 i
-                for i, q in enumerate(self.questions)
+                for i, q in enumerate(self.survey.questions)
                 if q.question_name == source_q_name
             )
             ref_edge = pydot.Edge(
@@ -87,7 +89,7 @@ class SurveyFlowVisualizationMixin:
         )
 
         # Add edges for normal flow through the survey
-        num_questions = len(self.questions)
+        num_questions = len(self.survey.questions)
         for index in range(num_questions - 1):
             graph.add_edge(pydot.Edge(f"Q{index}", f"Q{index+1}"))
 
@@ -95,7 +97,7 @@ class SurveyFlowVisualizationMixin:
 
         relevant_rules = [
             rule
-            for rule in self.rule_collection
+            for rule in self.survey.rule_collection
             if rule.priority > RulePriority.DEFAULT.value
         ]
 
@@ -159,10 +161,10 @@ class SurveyFlowVisualizationMixin:
                         on Ubuntu.
                     """
                 )
-            from edsl.utilities.utilities import is_notebook
+            from edsl.utilities.is_notebook import is_notebook
 
             if is_notebook():
-                from IPython.display import Image
+                from IPython.display import Image, display
 
                 display(Image(tmp_file.name))
             else:

edsl/surveys/SurveyToApp.py

@@ -0,0 +1,141 @@
+from fastapi import FastAPI
+from pydantic import BaseModel, create_model
+from typing import Callable, Optional, Type, Dict, Any, List, Union
+
+
+class SurveyToApp:
+    def __init__(self, survey):
+        self.survey = survey
+        self.app = FastAPI()
+
+    def parameters(self):
+        return self.survey.parameters
+
+    def create_input(self) -> Type[BaseModel]:
+        """
+        Creates a Pydantic model based on the survey parameters.
+        Returns:
+            Type[BaseModel]: A dynamically created Pydantic model class
+        """
+        # Get parameters from survey - now calling the method
+        params = self.parameters()
+
+        # Create field definitions dictionary
+        fields: Dict[str, Any] = {}
+
+        # Since params is a set, we'll handle each parameter directly
+        # Assuming each parameter in the set has the necessary attributes
+        for param in params:
+            # You might need to adjust these based on the actual parameter object structure
+            param_name = getattr(param, "name", str(param))
+            param_type = getattr(param, "type", "string")
+            is_required = getattr(param, "required", True)
+
+            # Map survey parameter types to Python types
+            type_mapping = {
+                "string": str,
+                "integer": int,
+                "float": float,
+                "boolean": bool,
+                "array": List,
+                # Add more type mappings as needed
+            }
+
+            # Get the Python type from mapping
+            python_type = type_mapping.get(param_type, str)
+
+            if is_required:
+                fields[param_name] = (python_type, ...)
+            else:
+                fields[param_name] = (Optional[python_type], None)
+
+        # Add the template variable 'name' that's used in the question text
+        fields["name"] = (str, ...)
+
+        # Create and return the Pydantic model
+        model_name = f"{self.survey.__class__.__name__}Model"
+        return create_model(model_name, **fields)
+
+    def create_route(self) -> Callable:
+        """
+        Creates a FastAPI route handler for the survey.
+        Returns:
+            Callable: A route handler function
+        """
+        input_model = self.create_input()
+
+        async def route_handler(input_data: input_model):
+            """
+            Handles the API route by processing the input data through the survey.
+            Args:
+                input_data: The validated input data matching the created Pydantic model
+            Returns:
+                dict: The processed survey results
+            """
+            # Convert Pydantic model to dict
+            data = input_data.dict()
+            print(data)
+            from edsl.scenarios.Scenario import Scenario
+
+            # Process the data through the survey
+            try:
+                s = Scenario(data)
+                results = self.survey.by(s).run()
+                return {
+                    "status": "success",
+                    "data": results.select("answer.*").to_scenario_list().to_dict(),
+                }
+            except Exception as e:
+                return {"status": "error", "message": str(e)}
+
+        return route_handler
+
+    def add_to_app(
+        self, app: FastAPI, path: str = "/survey", methods: List[str] = ["POST", "GET"]
+    ):
+        """
+        Adds the survey route to a FastAPI application.
+        Args:
+            app (FastAPI): The FastAPI application instance
+            path (str): The API endpoint path
+            methods (List[str]): HTTP methods to support
+        """
+        route_handler = self.create_route()
+        input_model = self.create_input()
+
+        app.add_api_route(
+            path, route_handler, methods=methods, response_model=Dict[str, Any]
+        )
+
+    def create_app(self, path: str = "/survey", methods: List[str] = ["POST", "GET"]):
+        """
+        Creates a FastAPI application with the survey route.
+        Args:
+            path (str): The API endpoint path
+            methods (List[str]): HTTP methods to support
+        Returns:
+            FastAPI: The FastAPI application instance
+        """
+        app = FastAPI()
+        self.add_to_app(app, path=path, methods=methods)
+        return app
+
+
+from edsl import QuestionFreeText, QuestionList
+
+# q = QuestionFreeText(
+#     question_name="name_gender",
+#     question_text="Is this customarily a boy's name or a girl's name: {{ name}}",
+# )
+
+q = QuestionList(
+    question_name="examples",
+    question_text="Give me {{ num }} examples of {{ thing }}",
+)
+
+survey_app = SurveyToApp(q.to_survey())
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(survey_app.create_app(path="/examples"), host="127.0.0.1", port=8000)

edsl/surveys/__init__.py

@@ -1,3 +1,5 @@
 from edsl.surveys.Survey import Survey
-from edsl.surveys.Rule import Rule
-from edsl.surveys.RuleCollection import RuleCollection
+from edsl.surveys.instructions.Instruction import Instruction
+
+# from edsl.surveys.Rule import Rule
+# from edsl.surveys.RuleCollection import RuleCollection

edsl/surveys/descriptors.py

@@ -1,8 +1,10 @@
 """This module contains the descriptors for the classes in the edsl package."""
 
 from abc import ABC, abstractmethod
-from typing import Any
-from edsl.questions.QuestionBase import QuestionBase
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from edsl.questions.QuestionBase import QuestionBase
 
 
 class BaseDescriptor(ABC):
@@ -36,6 +38,8 @@ class QuestionsDescriptor(BaseDescriptor):
 
     def validate(self, value: Any, instance) -> None:
         """Validate the value. If it is invalid, raise an exception. If it is valid, do nothing."""
+        from edsl.questions.QuestionBase import QuestionBase
+
         if not isinstance(value, list):
             raise TypeError("Questions must be a list.")
         if not all(isinstance(question, QuestionBase) for question in value):

edsl/surveys/instructions/ChangeInstruction.py

@@ -1,6 +1,5 @@
 from typing import List, Optional
-
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.utilities.remove_edsl_version import remove_edsl_version
 
 
 class ChangeInstruction:

edsl/surveys/instructions/Instruction.py

@@ -1,10 +1,9 @@
 from typing import Union, Optional, List, Generator, Dict
-from edsl.questions import QuestionBase
+from edsl.utilities.remove_edsl_version import remove_edsl_version
+from edsl.Base import RepresentationMixin
 
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
-
-class Instruction:
+class Instruction(RepresentationMixin):
     def __init__(
         self, name, text, preamble="You were given the following instructions:"
     ):
@@ -18,14 +17,6 @@ class Instruction:
     def __repr__(self):
         return """Instruction(name="{}", text="{}")""".format(self.name, self.text)
 
-    def _repr_html_(self):
-        d = self.to_dict(add_edsl_version=False)
-        data = [[k, v] for k, v in d.items()]
-        from tabulate import tabulate
-
-        table = str(tabulate(data, headers=["keys", "values"], tablefmt="html"))
-        return f"<pre>{table}</pre>"
-
     @classmethod
     def example(cls) -> "Instruction":
         return cls(name="example", text="This is an example instruction.")
@@ -45,7 +36,7 @@ class Instruction:
         return d
 
     def add_question(self, question) -> "Survey":
-        from edsl import Survey
+        from edsl.surveys.Survey import Survey
 
         return Survey([self, question])
 

edsl/surveys/instructions/InstructionCollection.py

@@ -1,17 +1,18 @@
+from typing import TYPE_CHECKING, Dict, List, Generator, Union
+from collections import UserDict
+
 from edsl.surveys.instructions.Instruction import Instruction
 from edsl.surveys.instructions.ChangeInstruction import ChangeInstruction
-from edsl.questions import QuestionBase
-from typing import Union, Optional, List, Generator, Dict
-
 
-from collections import UserDict
+if TYPE_CHECKING:
+    from edsl.questions.QuestionBase import QuestionBase
 
 
 class InstructionCollection(UserDict):
     def __init__(
         self,
         instruction_names_to_instruction: Dict[str, Instruction],
-        questions: List[QuestionBase],
+        questions: List["QuestionBase"],
     ):
         self.instruction_names_to_instruction = instruction_names_to_instruction
         self.questions = questions
@@ -24,6 +25,8 @@ class InstructionCollection(UserDict):
 
     def __getitem__(self, key):
         # in case the person uses question instead of the name
+        from edsl.questions.QuestionBase import QuestionBase
+
         if isinstance(key, QuestionBase):
             key = key.name
         return self.data[key]
@@ -54,9 +57,11 @@ class InstructionCollection(UserDict):
         return instructions, changes
 
     def relevant_instructions(
-        self, question: Union[str, QuestionBase]
+        self, question: Union[str, "QuestionBase"]
     ) -> Generator[Instruction, None, None]:
         ## Find all the questions that are after a given instruction
+        from edsl.questions.QuestionBase import QuestionBase
+
         if isinstance(question, str):
             question_name = question
         elif isinstance(question, QuestionBase):

edsl/templates/error_reporting/interview_details.html

@@ -31,7 +31,7 @@
  
             <tr>
                 <td>Human-readable question</td>
-                <td>{{ interview.survey.get_question(question).html(
+                <td>{{ interview.survey._get_question_by_name(question).html(
                     scenario = interview.scenario, 
                     agent = interview.agent,
                     answers = exception_message.answers) 

edsl/templates/error_reporting/report.html

@@ -82,7 +82,7 @@
 
                     <h2>Question</h2>
                     <div class="question-detail"> 
-                            {{ interview.survey.get_question(question).html() }}
+                            {{ interview.survey._get_question_by_name(question).html() }}
                     </div>        
 
                     <h2>Scenario</h2>                            

edsl/tools/plotting.py

@@ -11,7 +11,7 @@ def count_query(field):
 
 
 def get_options(results, field):
-    question_type = results.survey.get_question(field).question_type
+    question_type = results.survey._get_question_by_name(field).question_type
     if question_type in ["multiple_choice", "checkbox"]:
         return results.select(f"{field}_question_options").first()
     else:

edsl/utilities/PrettyList.py

@@ -0,0 +1,56 @@
+from collections import UserList
+from edsl.results.Dataset import Dataset
+
+
+class PrettyList(UserList):
+    def __init__(self, data=None, columns=None):
+        super().__init__(data)
+        self.columns = columns
+
+    def _repr_html_(self):
+        if isinstance(self[0], list) or isinstance(self[0], tuple):
+            num_cols = len(self[0])
+        else:
+            num_cols = 1
+
+        if self.columns:
+            columns = self.columns
+        else:
+            columns = list(range(num_cols))
+
+        d = {}
+        for column in columns:
+            d[column] = []
+
+        for row in self:
+            for index, column in enumerate(columns):
+                if isinstance(row, list) or isinstance(row, tuple):
+                    d[column].append(row[index])
+                else:
+                    d[column].append(row)
+        # raise ValueError(d)
+        return Dataset([{key: entry} for key, entry in d.items()])._repr_html_()
+
+        if num_cols > 1:
+            return (
+                "<pre><table>"
+                + "".join(["<th>" + str(column) + "</th>" for column in columns])
+                + "".join(
+                    [
+                        "<tr>"
+                        + "".join(["<td>" + str(x) + "</td>" for x in row])
+                        + "</tr>"
+                        for row in self
+                    ]
+                )
+                + "</table></pre>"
+            )
+        else:
+            return (
+                "<pre><table>"
+                + "".join(["<th>" + str(index) + "</th>" for index in columns])
+                + "".join(
+                    ["<tr>" + "<td>" + str(row) + "</td>" + "</tr>" for row in self]
+                )
+                + "</table></pre>"
+            )

edsl/utilities/is_notebook.py

@@ -0,0 +1,18 @@
+def is_notebook() -> bool:
+    """Check if the code is running in a Jupyter notebook or Google Colab."""
+    try:
+        shell = get_ipython().__class__.__name__
+        if shell == "ZMQInteractiveShell":
+            return True  # Jupyter notebook or qtconsole
+        elif shell == "Shell":  # Google Colab's shell class
+            import sys
+
+            if "google.colab" in sys.modules:
+                return True  # Running in Google Colab
+            return False
+        elif shell == "TerminalInteractiveShell":
+            return False  # Terminal running IPython
+        else:
+            return False  # Other type
+    except NameError:
+        return False  # Probably standard Python interpreter

edsl/utilities/is_valid_variable_name.py

@@ -0,0 +1,11 @@
+import keyword
+
+
+def is_valid_variable_name(name, allow_name=True):
+    """Check if a string is a valid variable name."""
+    if allow_name:
+        return name.isidentifier() and not keyword.iskeyword(name)
+    else:
+        return (
+            name.isidentifier() and not keyword.iskeyword(name) and not name == "name"
+        )

edsl/utilities/remove_edsl_version.py

@@ -0,0 +1,24 @@
+from functools import wraps
+
+
+def remove_edsl_version(func):
+    """
+    Decorator for the EDSL objects' `from_dict` method.
+    - Removes the EDSL version and class name from the dictionary.
+    - Ensures backwards compatibility with older versions of EDSL.
+    """
+
+    @wraps(func)
+    def wrapper(cls, data, *args, **kwargs):
+        data_copy = dict(data)
+        edsl_version = data_copy.pop("edsl_version", None)
+        edsl_classname = data_copy.pop("edsl_class_name", None)
+
+        # Version- and class-specific logic here
+        if edsl_classname == "Survey":
+            if edsl_version is None or edsl_version <= "0.1.20":
+                data_copy["question_groups"] = {}
+
+        return func(cls, data_copy, *args, **kwargs)
+
+    return wrapper

edsl/utilities/utilities.py

@@ -121,27 +121,27 @@ def clean_json(bad_json_str):
     return s
 
 
-def data_to_html(data, replace_new_lines=False):
-    if "edsl_version" in data:
-        _ = data.pop("edsl_version")
-    if "edsl_class_name" in data:
-        _ = data.pop("edsl_class_name")
-
-    from pygments import highlight
-    from pygments.lexers import JsonLexer
-    from pygments.formatters import HtmlFormatter
-    from IPython.display import HTML
-
-    json_str = json.dumps(data, indent=4, cls=CustomEncoder)
-    formatted_json = highlight(
-        json_str,
-        JsonLexer(),
-        HtmlFormatter(style="default", full=False, noclasses=False),
-    )
-    if replace_new_lines:
-        formatted_json = formatted_json.replace("\\n", "<br>")
+# def data_to_html(data, replace_new_lines=False):
+#     if "edsl_version" in data:
+#         _ = data.pop("edsl_version")
+#     if "edsl_class_name" in data:
+#         _ = data.pop("edsl_class_name")
+
+#     from pygments import highlight
+#     from pygments.lexers import JsonLexer
+#     from pygments.formatters import HtmlFormatter
+#     from IPython.display import HTML
 
-    return HTML(formatted_json).data
+#     json_str = json.dumps(data, indent=4, cls=CustomEncoder)
+#     formatted_json = highlight(
+#         json_str,
+#         JsonLexer(),
+#         HtmlFormatter(style="default", full=False, noclasses=False),
+#     )
+#     if replace_new_lines:
+#         formatted_json = formatted_json.replace("\\n", "<br>")
+
+#     return HTML(formatted_json).data
 
 
 def is_gzipped(file_path):
@@ -194,15 +194,21 @@ def dict_to_html(d):
 
 
 def is_notebook() -> bool:
-    """Check if the code is running in a Jupyter notebook."""
+    """Check if the code is running in a Jupyter notebook or Google Colab."""
     try:
         shell = get_ipython().__class__.__name__
         if shell == "ZMQInteractiveShell":
             return True  # Jupyter notebook or qtconsole
+        elif shell == "Shell":  # Google Colab's shell class
+            import sys
+
+            if "google.colab" in sys.modules:
+                return True  # Running in Google Colab
+            return False
         elif shell == "TerminalInteractiveShell":
             return False  # Terminal running IPython
         else:
-            return False  # Other type (e.g., IDLE, PyCharm, etc.)
+            return False  # Other type
     except NameError:
         return False  # Probably standard Python interpreter
 
@@ -406,11 +412,13 @@ def shorten_string(s, max_length, placeholder="..."):
     return s[:start_remove] + placeholder + s[end_remove:]
 
 
-def write_api_key_to_env(api_key: str) -> None:
+def write_api_key_to_env(api_key: str) -> str:
     """
     Write the user's Expected Parrot key to their .env file.
 
     If a .env file doesn't exist in the current directory, one will be created.
+
+    Returns a string representing the absolute path to the .env file.
     """
     from pathlib import Path
     from dotenv import set_key
@@ -422,3 +430,7 @@ def write_api_key_to_env(api_key: str) -> None:
 
     # Write API key to file
     set_key(env_path, "EXPECTED_PARROT_API_KEY", str(api_key))
+
+    absolute_path_to_env = env_file.absolute().as_posix()
+
+    return absolute_path_to_env