edsl 0.1.14__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/surveys/SurveyCSS.py

@@ -0,0 +1,273 @@
+from typing import Optional
+from edsl.utilities.remove_edsl_version import remove_edsl_version
+
+
+class CSSRuleMeta(type):
+    _instances = []
+
+    def __init__(cls, name, bases, dct):
+        super().__init__(name, bases, dct)
+
+    def __call__(cls, *args, **kwargs):
+        instance = super().__call__(*args, **kwargs)
+        cls._instances.append(instance)
+        return instance
+
+    @classmethod
+    def get_instances(cls):
+        return cls._instances
+
+
+class CSSRule(metaclass=CSSRuleMeta):
+    def __init__(self, selector: str, properties: Optional[dict[str, str]] = None):
+        """
+        A CSS rule object that represents a CSS rule with a selector and properties.
+
+        >>> rule = CSSRule("survey_container", {"width": "80%", "margin": "0 auto"})
+        >>> rule.generate_rule()
+        '.survey_container {\\n    width: 80%;\\n    margin: 0 auto;\\n}'
+        """
+        self.selector = selector
+        self.properties = properties if properties else {}
+
+    def add_property(self, property_name: str, value: str) -> "CSSRule":
+        """
+        >>> rule = CSSRule("survey_container")
+        >>> rule.add_property("width", "80%")
+        CSSRule(select = survey_container, properties = {'width': '80%'})
+        """
+        self.properties[property_name] = value
+        return self
+
+    def remove_property(self, property_name) -> "CSSRule":
+        """
+        >>> rule = CSSRule("survey_container", {"width": "80%", "margin": "0 auto"})
+        >>> rule.remove_property("margin")
+        CSSRule(select = survey_container, properties = {'width': '80%'})
+        """
+        if property_name in self.properties:
+            del self.properties[property_name]
+        return self
+
+    def generate_rule(self) -> str:
+        """
+        >>> rule = CSSRule("survey_container", {"width": "80%", "margin": "0 auto"})
+        >>> rule.generate_rule()
+        '.survey_container {\\n    width: 80%;\\n    margin: 0 auto;\\n}'
+        """
+        rule_lines = [f".{self.selector} {{"]
+        for prop, value in self.properties.items():
+            rule_lines.append(f"    {prop}: {value};")
+        rule_lines.append("}")
+        return "\n".join(rule_lines)
+
+    def __repr__(self) -> str:
+        return f"CSSRule(select = {self.selector}, properties = {self.properties})"
+
+    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': '...'}
+        """
+        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
+    def from_dict(cls, rule_dict) -> "CSSRule":
+        """
+        >>> rule_dict = {'selector': 'survey_container', 'properties': {'width': '80%', 'margin': '0 auto'}}
+        >>> CSSRule.from_dict(rule_dict)
+        CSSRule(select = survey_container, properties = {'width': '80%', 'margin': '0 auto'})
+        """
+        return CSSRule(
+            selector=rule_dict["selector"], properties=rule_dict["properties"]
+        )
+
+    @classmethod
+    def example(cls):
+        """
+        >>> CSSRule.example()
+        CSSRule(select = survey_container, properties = {'width': '80%', 'margin': '0 auto'})
+        """
+        return CSSRule(
+            selector="survey_container",
+            properties={
+                "width": "80%",
+                "margin": "0 auto",
+            },
+        )
+
+    def __str__(self):
+        return self.generate_rule()
+
+
+survey_container = CSSRule(
+    selector="survey_container",
+    properties={
+        "width": "80%",
+        "margin": "0 auto",
+        "padding": "20px",
+        "background-color": "#f9f9f9",
+        "border": "1px solid #ddd",
+        "border-radius": "8px",
+        "box-shadow": "0 2px 4px rgba(0, 0, 0, 0.1)",
+    },
+)
+
+survey_question = CSSRule(
+    selector="survey_question",
+    properties={
+        "margin-bottom": "20px",
+        "padding": "15px",
+        "background-color": "#fff",
+        "border": "1px solid #ddd",
+        "border-radius": "8px",
+    },
+)
+
+question_text = CSSRule(
+    selector="question_text",
+    properties={
+        "font-size": "18px",
+        "font-weight": "bold",
+        "margin-bottom": "10px",
+        "color": "#333",
+    },
+)
+
+question_options = CSSRule(
+    selector="question_options",
+    properties={
+        "list-style-type": "none",
+        "padding": "0",
+        "margin": "0",
+    },
+)
+
+question_options_li = CSSRule(
+    selector="question_options li",
+    properties={
+        "margin-bottom": "10px",
+        "font-size": "16px",
+        "color": "#555",
+    },
+)
+
+question_options_radio = CSSRule(
+    selector="question_options input[type='radio']",
+    properties={
+        "margin-right": "10px",
+    },
+)
+
+question_options_checkbox = CSSRule(
+    selector="question_options input[type='checkbox']",
+    properties={
+        "margin-right": "10px",
+    },
+)
+
+input_text = CSSRule(
+    selector="input[type='text']",
+    properties={
+        "width": "100%",
+        "padding": "10px",
+        "font-size": "16px",
+        "border": "1px solid #ddd",
+        "border-radius": "4px",
+        "box-sizing": "border-box",
+    },
+)
+
+
+class SurveyCSS:
+    def __init__(self, rules: Optional[list["CSSRule"]] = None):
+        self.rules = {rule.selector: rule for rule in rules} if rules else {}
+
+    def update_style(self, selector, property_name, new_value):
+        """
+        >>> css = SurveyCSS()
+        >>> css.update_style("survey_container", "width", "100%").rules["survey_container"].properties["width"]
+        '100%'
+        """
+        if selector not in self.rules:
+            self.rules[selector] = CSSRule(selector)
+        self.rules[selector].add_property(property_name, new_value)
+        return self
+
+    def remove_style(self, selector, property_name):
+        """
+        >>> css = SurveyCSS().update_style("survey_container", "width", "100%")
+        >>> css.remove_style("survey_container", "width").rules["survey_container"].properties
+        {}
+        """
+        if selector in self.rules:
+            self.rules[selector].remove_property(property_name)
+        return self
+
+    def generate_css(self):
+        """
+        >>> SurveyCSS(rules = []).update_style("survey_container", "width", "100%").generate_css()
+        '.survey_container {\\n    width: 100%;\\n}'
+
+        """
+        css_lines = []
+        for rule in self.rules.values():
+            css_lines.append(rule.generate_rule())
+        return "\n".join(css_lines)
+
+    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'}
+        """
+        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()]})"
+
+    @classmethod
+    @remove_edsl_version
+    def from_dict(cls, css_dict) -> "SurveyCSS":
+        """
+        >>> s = SurveyCSS.example()
+        >>> SurveyCSS.from_dict(s.to_dict())
+        SurveyCSS(rules = [CSSRule(select = survey_container, properties = {'width': '80%', 'margin': '0 auto', 'padding': '20px', 'background-color': '#f9f9f9', 'border': '1px solid #ddd', 'border-radius': '8px', 'box-shadow': '0 2px 4px rgba(0, 0, 0, 0.1)'})])
+        """
+        return SurveyCSS(
+            rules=[CSSRule.from_dict(rule_dict) for rule_dict in css_dict["rules"]]
+        )
+
+    @classmethod
+    def default_style(cls):
+        return SurveyCSS(rules=CSSRuleMeta.get_instances())
+
+    @classmethod
+    def example(cls):
+        """
+        >>> SurveyCSS.example()
+        SurveyCSS(rules = [CSSRule(select = survey_container, properties = {'width': '80%', 'margin': '0 auto', 'padding': '20px', 'background-color': '#f9f9f9', 'border': '1px solid #ddd', 'border-radius': '8px', 'box-shadow': '0 2px 4px rgba(0, 0, 0, 0.1)'})])
+        """
+        return SurveyCSS(rules=[survey_container])
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/surveys/SurveyExportMixin.py

@@ -1,11 +1,62 @@
-from docx import Document
+"""A mixin class for exporting surveys to different formats."""
+
+from typing import Union, Optional
+
+import subprocess
+import platform
+import os
+import tempfile
+
+
+def open_docx(file_path):
+    """
+    Open a docx file using the default application in a cross-platform manner.
+
+    :param file_path: str, path to the docx file
+    """
+    file_path = os.path.abspath(file_path)
+
+    if platform.system() == "Darwin":  # macOS
+        subprocess.call(("open", file_path))
+    elif platform.system() == "Windows":  # Windows
+        os.startfile(file_path)
+    else:  # linux variants
+        subprocess.call(("xdg-open", file_path))
 
 
 class SurveyExportMixin:
-    def docx(self) -> "Document":
-        "Generates a docx document for the survey"
+    """A mixin class for exporting surveys to different formats."""
+
+    def css(self):
+        from edsl.surveys.SurveyCSS import SurveyCSS
+
+        return SurveyCSS.default_style().generate_css()
+
+    def get_description(self) -> str:
+        """Return the description of the survey."""
+        from edsl import QuestionFreeText
+
+        question_texts = "\n".join([q.question_text for q in self._questions])
+        q = QuestionFreeText(
+            question_name="description",
+            question_text=f"""A survey was conducted with the following questions: 
+                             {question_texts}
+                             Please write a description of the survey.
+                             """,
+        )
+        return q.run().select("description").first()
+
+    def docx(
+        self,
+        return_document_object: bool = False,
+        filename: Optional[str] = None,
+        open_file: bool = False,
+    ) -> Union["Document", None]:
+        """Generate a docx document for the survey."""
+        from docx import Document
+
         doc = Document()
-        doc.add_heading("EDSL Auto-Generated Survey")
+        doc.add_heading("EDSL Survey")
         doc.add_paragraph(f"\n")
         for index, question in enumerate(self._questions):
             h = doc.add_paragraph()  # Add question as a paragraph
@@ -20,45 +71,189 @@ class SurveyExportMixin:
                 if hasattr(question, "question_options"):
                     for option in getattr(question, "question_options", []):
                         doc.add_paragraph(str(option), style="ListBullet")
-        return doc
 
-    def code(self) -> list[str]:
-        ## TODO: Refactor to only use the questions actually in the survey
-        "Creates the Python code representation of a survey"
+        if return_document_object and filename is None:
+            return doc
+
+        if filename is None:
+            with tempfile.NamedTemporaryFile(
+                "w", delete=False, suffix=".docx", dir=os.getcwd()
+            ) as f:
+                filename = f.name
+
+        doc.save(filename)
+        print("The survey has been saved to", filename)
+        if open_file:
+            open_docx(filename)
+        return
+
+    def show(self):
+        self.to_scenario_list(questions_only=False, rename=True).print(format="rich")
+
+    def to_scenario_list(
+        self, questions_only: bool = True, rename=False
+    ) -> "ScenarioList":
+        from edsl import ScenarioList, Scenario
+
+        # from edsl.questions import QuestionBase
+
+        if questions_only:
+            to_iterate_over = self._questions
+        else:
+            to_iterate_over = self.recombined_questions_and_instructions()
+
+        if rename:
+            renaming_dict = {
+                "name": "identifier",
+                "question_name": "identifier",
+                "question_text": "text",
+            }
+        else:
+            renaming_dict = {}
+
+        all_keys = set([])
+        scenarios = ScenarioList()
+        for item in to_iterate_over:
+            d = item.to_dict()
+            if item.__class__.__name__ == "Instruction":
+                d["question_type"] = "NA / instruction"
+            for key in renaming_dict:
+                if key in d:
+                    d[renaming_dict[key]] = d.pop(key)
+            all_keys.update(d.keys())
+            scenarios.append(Scenario(d))
+
+        for scenario in scenarios:
+            for key in all_keys:
+                if key not in scenario:
+                    scenario[key] = None
+
+        return scenarios
+
+    def code(self, filename: str = None, survey_var_name: str = "survey") -> list[str]:
+        """Create the Python code representation of a survey.
+
+        :param filename: The name of the file to save the code to.
+        :param survey_var_name: The name of the survey variable.
+
+        >>> from edsl.surveys import Survey
+        >>> survey = Survey.example()
+        >>> print(survey.code())
+        from edsl.surveys.Survey import Survey
+        ...
+        ...
+        survey = Survey(questions=[q0, q1, q2])
+        ...
+        """
+        import black
+
         header_lines = ["from edsl.surveys.Survey import Survey"]
-        header_lines.append(
-            "from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice"
-        )
-        header_lines.append(
-            "from edsl.questions.QuestionFreeText import QuestionFreeText"
-        )
-        header_lines.append(
-            "from edsl.questions.derived.QuestionLinearScale import QuestionLinearScale"
-        )
-        header_lines.append(
-            "from edsl.questions.QuestionNumerical import QuestionNumerical"
-        )
-        header_lines.append(
-            "from edsl.questions.QuestionCheckBox import QuestionCheckBox"
-        )
-        header_lines.append(
-            "from edsl.questions.derived.QuestionYesNo import QuestionYesNo"
-        )
+        header_lines.append("from edsl import Question")
         lines = ["\n".join(header_lines)]
         for question in self._questions:
+            question.question_text = question["question_text"].replace("\n", " ")
+            # remove dublicate spaces
+            question.question_text = " ".join(question.question_text.split())
             lines.append(f"{question.question_name} = " + repr(question))
-        lines.append(f"survey = Survey(questions = [{', '.join(self.question_names)}])")
-        return lines
+        lines.append(
+            f"{survey_var_name} = Survey(questions = [{', '.join(self.question_names)}])"
+        )
+        # return lines
+        code_string = "\n".join(lines)
+        formatted_code = black.format_str(code_string, mode=black.FileMode())
 
-    def html(self) -> str:
-        "Generates the html for the survey"
-        html_text = []
-        for question in self._questions:
-            html_text.append(
-                f"<p><b>{question.question_name}</b> ({question.question_type}): {question.question_text}</p>"
-            )
-            html_text.append("<ul>")
-            for option in getattr(question, "question_options", []):
-                html_text.append(f"<li>{option}</li>")
-            html_text.append("</ul>")
-        return "\n".join(html_text)
+        if filename:
+            print("The code has been saved to", filename)
+            print("The survey itself is saved to 'survey' object")
+            with open(filename, "w") as file:
+                file.write(formatted_code)
+            return
+
+        return formatted_code
+
+    def html(
+        self,
+        scenario: Optional[dict] = None,
+        filename: Optional[str] = None,
+        return_link=False,
+        css: Optional[str] = None,
+        cta: Optional[str] = "Open HTML file",
+        include_question_name=False,
+    ):
+        from IPython.display import display, HTML
+        import tempfile
+        import os
+        from edsl.utilities.utilities import is_notebook
+
+        if scenario is None:
+            scenario = {}
+
+        if css is None:
+            css = self.css()
+
+        if filename is None:
+            current_directory = os.getcwd()
+            filename = tempfile.NamedTemporaryFile(
+                "w", delete=False, suffix=".html", dir=current_directory
+            ).name
+
+        html_header = f"""<html>
+        <head><title></title>
+        <style>
+        { css }
+        </style>
+        </head>
+        <body>
+        <div class="survey_container">
+        """
+
+        html_footer = """
+        </div>
+        </body>
+        </html>"""
+
+        output = html_header
+
+        with open(filename, "w") as f:
+            f.write(html_header)
+            for question in self._questions:
+                f.write(
+                    question.html(
+                        scenario=scenario, include_question_name=include_question_name
+                    )
+                )
+                output += question.html(
+                    scenario=scenario, include_question_name=include_question_name
+                )
+            f.write(html_footer)
+            output += html_footer
+
+        if is_notebook():
+            html_url = f"/files/{filename}"
+            html_link = f'<a href="{html_url}" target="_blank">{cta}</a>'
+            display(HTML(html_link))
+
+            import html
+
+            escaped_output = html.escape(output)
+            iframe = f""""
+            <iframe srcdoc="{ escaped_output }" style="width: 800px; height: 600px;"></iframe>
+            """
+            display(HTML(iframe))
+
+        else:
+            print(f"Survey saved to {filename}")
+            import webbrowser
+            import os
+
+            webbrowser.open(f"file://{os.path.abspath(filename)}")
+            # webbrowser.open(filename)
+
+        if return_link:
+            return filename
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)