edsl 0.1.37.dev4__py3-none-any.whl → 0.1.37.dev5__py3-none-any.whl

edsl/conjure/InputDataStata.py

@@ -1,8 +1,8 @@
-from edsl.conjure.InputDataPyRead import InputDataPyRead
-
-
-class InputDataStata(InputDataPyRead):
-    def pyread_function(self, datafile_name):
-        from pyreadstat import read_dta
-
-        return read_dta(datafile_name)
+from edsl.conjure.InputDataPyRead import InputDataPyRead
+
+
+class InputDataStata(InputDataPyRead):
+    def pyread_function(self, datafile_name):
+        from pyreadstat import read_dta
+
+        return read_dta(datafile_name)

edsl/conjure/QuestionOptionMixin.py

@@ -1,76 +1,76 @@
-from typing import Union, List
-
-
-class QuestionOptionMixin:
-    @property
-    def question_options(self):
-        if not hasattr(self, "_question_options"):
-            self.question_options = None
-        return self._question_options
-
-    @question_options.setter
-    def question_options(self, value):
-        if value is None:
-            value = [self._get_question_options(qn) for qn in self.question_names]
-        self._question_options = value
-
-    def _get_question_options(self, question_name) -> Union[List[str], None]:
-        """Return the options for a question.
-
-        >>> from edsl.conjure.InputData import InputDataABC
-        >>> id = InputDataABC.example()
-        >>> sorted(id._get_question_options('morning'))
-        ['1', '4']
-
-        """
-        qt = self.question_statistics(question_name)
-        idx = self.question_names.index(question_name)
-        question_type = self.question_types[idx]
-        if question_type == "multiple_choice":
-            return [str(o) for o in qt.unique_responses]
-        else:
-            if question_type == "multiple_choice_with_other":
-                options = self.unique_responses_more_than_k(2)[
-                    self.question_names.index(question_name)
-                ] + [self.OTHER_STRING]
-                return [str(o) for o in options]
-            else:
-                return None
-
-    def order_options(self) -> None:
-        """Order the options for multiple choice questions using an LLM."""
-        from edsl import QuestionList, ScenarioList
-        import textwrap
-
-        scenarios = (
-            ScenarioList.from_list("example_question_name", self.question_names)
-            .add_list("example_question_text", self.question_texts)
-            .add_list("example_question_type", self.question_types)
-            .add_list("example_question_options", self.question_options)
-        ).filter(
-            'example_question_type == "multiple_choice" or example_question_type == "multiple_choice_with_other"'
-        )
-
-        question = QuestionList(
-            question_text=textwrap.dedent(
-                """\
-            We have a survey question: `{{ example_question_text }}`.
-            
-            The survey had following options: '{{ example_question_options }}'.
-            The options might be out of order. Please put them in the correct order.
-            If there is not natural order, just put then in order they were presented.
-            """
-            ),
-            question_name="ordering",
-        )
-        proposed_ordering = question.by(scenarios).run()
-        d = dict(
-            proposed_ordering.select("example_question_name", "ordering").to_list()
-        )
-        self._question_options = [d.get(qn, None) for qn in self.question_names]
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+from typing import Union, List
+
+
+class QuestionOptionMixin:
+    @property
+    def question_options(self):
+        if not hasattr(self, "_question_options"):
+            self.question_options = None
+        return self._question_options
+
+    @question_options.setter
+    def question_options(self, value):
+        if value is None:
+            value = [self._get_question_options(qn) for qn in self.question_names]
+        self._question_options = value
+
+    def _get_question_options(self, question_name) -> Union[List[str], None]:
+        """Return the options for a question.
+
+        >>> from edsl.conjure.InputData import InputDataABC
+        >>> id = InputDataABC.example()
+        >>> sorted(id._get_question_options('morning'))
+        ['1', '4']
+
+        """
+        qt = self.question_statistics(question_name)
+        idx = self.question_names.index(question_name)
+        question_type = self.question_types[idx]
+        if question_type == "multiple_choice":
+            return [str(o) for o in qt.unique_responses]
+        else:
+            if question_type == "multiple_choice_with_other":
+                options = self.unique_responses_more_than_k(2)[
+                    self.question_names.index(question_name)
+                ] + [self.OTHER_STRING]
+                return [str(o) for o in options]
+            else:
+                return None
+
+    def order_options(self) -> None:
+        """Order the options for multiple choice questions using an LLM."""
+        from edsl import QuestionList, ScenarioList
+        import textwrap
+
+        scenarios = (
+            ScenarioList.from_list("example_question_name", self.question_names)
+            .add_list("example_question_text", self.question_texts)
+            .add_list("example_question_type", self.question_types)
+            .add_list("example_question_options", self.question_options)
+        ).filter(
+            'example_question_type == "multiple_choice" or example_question_type == "multiple_choice_with_other"'
+        )
+
+        question = QuestionList(
+            question_text=textwrap.dedent(
+                """\
+            We have a survey question: `{{ example_question_text }}`.
+            
+            The survey had following options: '{{ example_question_options }}'.
+            The options might be out of order. Please put them in the correct order.
+            If there is not natural order, just put then in order they were presented.
+            """
+            ),
+            question_name="ordering",
+        )
+        proposed_ordering = question.by(scenarios).run()
+        d = dict(
+            proposed_ordering.select("example_question_name", "ordering").to_list()
+        )
+        self._question_options = [d.get(qn, None) for qn in self.question_names]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/conjure/QuestionTypeMixin.py

@@ -1,23 +1,23 @@
-class QuestionTypeMixin:
-    @property
-    def question_types(self):
-        if not hasattr(self, "_question_types"):
-            self.question_types = None
-        return self._question_types
-
-    @question_types.setter
-    def question_types(self, value):
-        if value is None:
-            value = [self._infer_question_type(qn) for qn in self.question_names]
-        self._question_types = value
-
-    def _infer_question_type(self, question_name) -> str:
-        qt = self.question_statistics(question_name)
-        if qt.num_unique_responses > self.NUM_UNIQUE_THRESHOLD:
-            if qt.frac_numerical > self.FRAC_NUMERICAL_THRESHOLD:
-                return "numerical"
-            if qt.frac_obs_from_top_5 > self.MULTIPLE_CHOICE_OTHER_THRESHOLD:
-                return "multiple_choice_with_other"
-            return "free_text"
-        else:
-            return "multiple_choice"
+class QuestionTypeMixin:
+    @property
+    def question_types(self):
+        if not hasattr(self, "_question_types"):
+            self.question_types = None
+        return self._question_types
+
+    @question_types.setter
+    def question_types(self, value):
+        if value is None:
+            value = [self._infer_question_type(qn) for qn in self.question_names]
+        self._question_types = value
+
+    def _infer_question_type(self, question_name) -> str:
+        qt = self.question_statistics(question_name)
+        if qt.num_unique_responses > self.NUM_UNIQUE_THRESHOLD:
+            if qt.frac_numerical > self.FRAC_NUMERICAL_THRESHOLD:
+                return "numerical"
+            if qt.frac_obs_from_top_5 > self.MULTIPLE_CHOICE_OTHER_THRESHOLD:
+                return "multiple_choice_with_other"
+            return "free_text"
+        else:
+            return "multiple_choice"

edsl/conjure/RawQuestion.py

@@ -1,65 +1,65 @@
-from dataclasses import dataclass, field
-from typing import List, Optional, Union
-from edsl.questions import QuestionBase
-from edsl import Question
-
-from edsl.conjure.utilities import convert_value
-
-
-@dataclass
-class RawQuestion:
-    """
-    A class to represent a question before it is converted to edsl class.
-
-    >>> rq = RawQuestion.example()
-    >>> rq.to_question()
-    Question('multiple_choice', question_name = \"""how_are_you\""", question_text = \"""How are you doing?\""", question_options = ['Good', 'Bad'])
-    """
-
-    question_type: str
-    question_name: str
-    question_text: str
-    responses: List[str] = field(default_factory=list)
-    question_options: Optional[List[str]] = None
-
-    @classmethod
-    def example(cls):
-        return cls(
-            question_type="multiple_choice",
-            question_name="how_are_you",
-            question_text="How are you doing?",
-            responses=["Good", "Bad", "Bad", "Good"],
-            question_options=["Good", "Bad"],
-        )
-
-    def __post_init__(self):
-        self.responses = [convert_value(r) for r in self.responses]
-
-    def to_question(self) -> QuestionBase:
-        """Return a Question object from the RawQuestion."""
-
-        # TODO: Remove this once we have a better way to handle multiple_choice_with_other
-        if self.question_type == "multiple_choice_with_other":
-            question_type = "multiple_choice"
-        else:
-            question_type = self.question_type
-
-        # exclude responses from the dictionary if they have a None value; don't inlcude responses in the dictionary
-        d = {
-            k: v
-            for k, v in {
-                "question_type": question_type,
-                "question_name": self.question_name,
-                "question_text": self.question_text,
-                "responses": self.responses,
-                "question_options": self.question_options,
-            }.items()
-            if v is not None and k != "responses"
-        }
-        return Question(**d)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from edsl.questions import QuestionBase
+from edsl import Question
+
+from edsl.conjure.utilities import convert_value
+
+
+@dataclass
+class RawQuestion:
+    """
+    A class to represent a question before it is converted to edsl class.
+
+    >>> rq = RawQuestion.example()
+    >>> rq.to_question()
+    Question('multiple_choice', question_name = \"""how_are_you\""", question_text = \"""How are you doing?\""", question_options = ['Good', 'Bad'])
+    """
+
+    question_type: str
+    question_name: str
+    question_text: str
+    responses: List[str] = field(default_factory=list)
+    question_options: Optional[List[str]] = None
+
+    @classmethod
+    def example(cls):
+        return cls(
+            question_type="multiple_choice",
+            question_name="how_are_you",
+            question_text="How are you doing?",
+            responses=["Good", "Bad", "Bad", "Good"],
+            question_options=["Good", "Bad"],
+        )
+
+    def __post_init__(self):
+        self.responses = [convert_value(r) for r in self.responses]
+
+    def to_question(self) -> QuestionBase:
+        """Return a Question object from the RawQuestion."""
+
+        # TODO: Remove this once we have a better way to handle multiple_choice_with_other
+        if self.question_type == "multiple_choice_with_other":
+            question_type = "multiple_choice"
+        else:
+            question_type = self.question_type
+
+        # exclude responses from the dictionary if they have a None value; don't inlcude responses in the dictionary
+        d = {
+            k: v
+            for k, v in {
+                "question_type": question_type,
+                "question_name": self.question_name,
+                "question_text": self.question_text,
+                "responses": self.responses,
+                "question_options": self.question_options,
+            }.items()
+            if v is not None and k != "responses"
+        }
+        return Question(**d)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/conjure/SurveyResponses.py

@@ -1,7 +1,7 @@
-from typing import Dict, List
-from collections import UserDict
-
-
-class SurveyResponses(UserDict):
-    def __init__(self, responses: Dict[str, List[str]]):
-        super().__init__(responses)
+from typing import Dict, List
+from collections import UserDict
+
+
+class SurveyResponses(UserDict):
+    def __init__(self, responses: Dict[str, List[str]]):
+        super().__init__(responses)

edsl/conjure/__init__.py

@@ -1,9 +1,9 @@
-# from edsl.conjure.SurveyBuilder import SurveyBuilder
-# from edsl.conjure.SurveyBuilderCSV import SurveyBuilderCSV
-# from edsl.conjure.SurveyBuilderCSV import SurveyBuilderStata
-# from edsl.conjure.SurveyBuilderSPSS import SurveyBuilderSPSS
-# from edsl.conjure.InputData.InputDataSPSS import InputDataSPSS
-# from edsl.conjure.InputData.InputDataCSV import InputDataCSV
-# from edsl.conjure.InputData.InputDataStata import InputDataStata
-# from edsl.conjure.InputData import InputDataSPSS
-# from edsl.conjure.InputData import InputData
+# from edsl.conjure.SurveyBuilder import SurveyBuilder
+# from edsl.conjure.SurveyBuilderCSV import SurveyBuilderCSV
+# from edsl.conjure.SurveyBuilderCSV import SurveyBuilderStata
+# from edsl.conjure.SurveyBuilderSPSS import SurveyBuilderSPSS
+# from edsl.conjure.InputData.InputDataSPSS import InputDataSPSS
+# from edsl.conjure.InputData.InputDataCSV import InputDataCSV
+# from edsl.conjure.InputData.InputDataStata import InputDataStata
+# from edsl.conjure.InputData import InputDataSPSS
+# from edsl.conjure.InputData import InputData