edsl 0.1.37.dev6__py3-none-any.whl → 0.1.38__py3-none-any.whl

edsl/surveys/base.py

@@ -1,53 +1,53 @@
-"""Base classes and enumerations for the surveyor package."""
-
-from enum import Enum
-
-
-class RulePriority(Enum):
-    """Enumeration of the priority of a rule."""
-
-    DEFAULT = -1
-
-
-class EndOfSurveyParent:
-    """A named object that represents the end of the survey."""
-
-    pass
-
-    def __repr__(self):
-        """Return a string representation of the object."""
-        return "EndOfSurvey"
-
-    def __str__(self):
-        """Return a string representation of the object."""
-        return "EndOfSurvey"
-
-    def __bool__(self):
-        """Return False."""
-        return False
-
-    def __add__(self, other):
-        """Add the object to another object.
-
-        Example:
-        >>> e = EndOfSurveyParent()
-        >>> e + 1
-        EndOfSurvey
-        """
-        return self
-
-    def __deepcopy__(self, memo):
-        # Return the same instance when deepcopy is called
-        return self
-
-    def __radd__(self, other):
-        """Add the object to another object.
-
-        Example:
-        >>> 1 + EndOfSurveyParent()
-        EndOfSurvey
-        """
-        return self
-
-
-EndOfSurvey = EndOfSurveyParent()
+"""Base classes and enumerations for the surveyor package."""
+
+from enum import Enum
+
+
+class RulePriority(Enum):
+    """Enumeration of the priority of a rule."""
+
+    DEFAULT = -1
+
+
+class EndOfSurveyParent:
+    """A named object that represents the end of the survey."""
+
+    pass
+
+    def __repr__(self):
+        """Return a string representation of the object."""
+        return "EndOfSurvey"
+
+    def __str__(self):
+        """Return a string representation of the object."""
+        return "EndOfSurvey"
+
+    def __bool__(self):
+        """Return False."""
+        return False
+
+    def __add__(self, other):
+        """Add the object to another object.
+
+        Example:
+        >>> e = EndOfSurveyParent()
+        >>> e + 1
+        EndOfSurvey
+        """
+        return self
+
+    def __deepcopy__(self, memo):
+        # Return the same instance when deepcopy is called
+        return self
+
+    def __radd__(self, other):
+        """Add the object to another object.
+
+        Example:
+        >>> 1 + EndOfSurveyParent()
+        EndOfSurvey
+        """
+        return self
+
+
+EndOfSurvey = EndOfSurveyParent()

edsl/surveys/descriptors.py

@@ -1,56 +1,56 @@
-"""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
-
-
-class BaseDescriptor(ABC):
-    """ABC for something."""
-
-    @abstractmethod
-    def validate(self, value: Any) -> None:
-        """Validate the value. If it is invalid, raise an exception. If it is valid, do nothing."""
-        pass
-
-    def __get__(self, instance, owner):
-        """Get the value of the attribute."""
-        return instance.__dict__[self.name]
-
-    def __set__(self, instance, value: Any) -> None:
-        """Set the value of the attribute."""
-        self.validate(value, instance)
-        instance.__dict__[self.name] = value
-
-    def __set_name__(self, owner, name: str) -> None:
-        """Set the name of the attribute."""
-        self.name = "_" + name
-
-
-class QuestionsDescriptor(BaseDescriptor):
-    """Descriptor for questions."""
-
-    def __get__(self, instance, owner):
-        """Get the value of the attribute."""
-        return instance.__dict__[self.name]
-
-    def validate(self, value: Any, instance) -> None:
-        """Validate the value. If it is invalid, raise an exception. If it is valid, do nothing."""
-        if not isinstance(value, list):
-            raise TypeError("Questions must be a list.")
-        if not all(isinstance(question, QuestionBase) for question in value):
-            raise TypeError("Questions must be a list of Question objects.")
-        question_names = [question.question_name for question in value]
-        if len(question_names) != len(set(question_names)):
-            raise ValueError("Question names must be unique.")
-
-    def __set__(self, instance, value: Any) -> None:
-        """Set the value of the attribute."""
-        self.validate(value, instance)
-        instance.__dict__[self.name] = []
-        for question in value:
-            instance.add_question(question)
-
-    def __set_name__(self, owner, name: str) -> None:
-        """Set the name of the attribute."""
-        self.name = "_" + name
+"""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
+
+
+class BaseDescriptor(ABC):
+    """ABC for something."""
+
+    @abstractmethod
+    def validate(self, value: Any) -> None:
+        """Validate the value. If it is invalid, raise an exception. If it is valid, do nothing."""
+        pass
+
+    def __get__(self, instance, owner):
+        """Get the value of the attribute."""
+        return instance.__dict__[self.name]
+
+    def __set__(self, instance, value: Any) -> None:
+        """Set the value of the attribute."""
+        self.validate(value, instance)
+        instance.__dict__[self.name] = value
+
+    def __set_name__(self, owner, name: str) -> None:
+        """Set the name of the attribute."""
+        self.name = "_" + name
+
+
+class QuestionsDescriptor(BaseDescriptor):
+    """Descriptor for questions."""
+
+    def __get__(self, instance, owner):
+        """Get the value of the attribute."""
+        return instance.__dict__[self.name]
+
+    def validate(self, value: Any, instance) -> None:
+        """Validate the value. If it is invalid, raise an exception. If it is valid, do nothing."""
+        if not isinstance(value, list):
+            raise TypeError("Questions must be a list.")
+        if not all(isinstance(question, QuestionBase) for question in value):
+            raise TypeError("Questions must be a list of Question objects.")
+        question_names = [question.question_name for question in value]
+        if len(question_names) != len(set(question_names)):
+            raise ValueError("Question names must be unique.")
+
+    def __set__(self, instance, value: Any) -> None:
+        """Set the value of the attribute."""
+        self.validate(value, instance)
+        instance.__dict__[self.name] = []
+        for question in value:
+            instance.add_question(question)
+
+    def __set_name__(self, owner, name: str) -> None:
+        """Set the name of the attribute."""
+        self.name = "_" + name

edsl/surveys/instructions/ChangeInstruction.py

@@ -1,47 +1,49 @@
-from typing import List, Optional
-
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
-
-
-class ChangeInstruction:
-    def __init__(
-        self,
-        keep: Optional[List[str]] = None,
-        drop: Optional[List[str]] = None,
-    ):
-        if keep is None and drop is None:
-            raise ValueError("Keep and drop cannot both be None")
-
-        self.keep = keep or []
-        self.drop = drop or []
-
-    def include_instruction(self, instruction_name) -> bool:
-        return (instruction_name in self.keep) or (not instruction_name in self.drop)
-
-    def add_name(self, index) -> None:
-        self.name = "change_instruction_{}".format(index)
-
-    def __str__(self):
-        return self.text
-
-    def _to_dict(self):
-        return {
-            "keep": self.keep,
-            "drop": self.drop,
-            "edsl_class_name": "ChangeInstruction",
-        }
-
-    @add_edsl_version
-    def to_dict(self):
-        return self._to_dict()
-
-    def __hash__(self) -> int:
-        """Return a hash of the question."""
-        from edsl.utilities.utilities import dict_hash
-
-        return dict_hash(self._to_dict())
-
-    @classmethod
-    @remove_edsl_version
-    def from_dict(cls, data):
-        return cls(data["keep"], data["drop"])
+from typing import List, Optional
+
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+
+
+class ChangeInstruction:
+    def __init__(
+        self,
+        keep: Optional[List[str]] = None,
+        drop: Optional[List[str]] = None,
+    ):
+        if keep is None and drop is None:
+            raise ValueError("Keep and drop cannot both be None")
+
+        self.keep = keep or []
+        self.drop = drop or []
+
+    def include_instruction(self, instruction_name) -> bool:
+        return (instruction_name in self.keep) or (not instruction_name in self.drop)
+
+    def add_name(self, index) -> None:
+        self.name = "change_instruction_{}".format(index)
+
+    def __str__(self):
+        return self.text
+
+    def to_dict(self, add_edsl_version=True):
+        d = {
+            "keep": self.keep,
+            "drop": self.drop,
+        }
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "ChangeInstruction"
+
+        return d
+
+    def __hash__(self) -> int:
+        """Return a hash of the question."""
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self.to_dict(add_edsl_version=False))
+
+    @classmethod
+    @remove_edsl_version
+    def from_dict(cls, data):
+        return cls(data["keep"], data["drop"])

edsl/surveys/instructions/Instruction.py

@@ -1,51 +1,65 @@
-from typing import Union, Optional, List, Generator, Dict
-from edsl.questions import QuestionBase
-
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
-
-
-class Instruction:
-    def __init__(
-        self, name, text, preamble="You were given the following instructions:"
-    ):
-        self.name = name
-        self.text = text
-        self.preamble = preamble
-
-    def __str__(self):
-        return self.text
-
-    def __repr__(self):
-        return """Instruction(name="{}", text="{}")""".format(self.name, self.text)
-
-    def _to_dict(self):
-        return {
-            "name": self.name,
-            "text": self.text,
-            "edsl_class_name": "Instruction",
-            "preamble": self.preamble,
-        }
-
-    def add_question(self, question) -> "Survey":
-        from edsl import Survey
-
-        return Survey([self, question])
-
-    @add_edsl_version
-    def to_dict(self):
-        return self._to_dict()
-
-    def __hash__(self) -> int:
-        """Return a hash of the question."""
-        from edsl.utilities.utilities import dict_hash
-
-        return dict_hash(self._to_dict())
-
-    @classmethod
-    @remove_edsl_version
-    def from_dict(cls, data):
-        return cls(
-            data["name"],
-            data["text"],
-            data.get("preamble", "You were given the following instructions:"),
-        )
+from typing import Union, Optional, List, Generator, Dict
+from edsl.questions import QuestionBase
+
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+
+
+class Instruction:
+    def __init__(
+        self, name, text, preamble="You were given the following instructions:"
+    ):
+        self.name = name
+        self.text = text
+        self.preamble = preamble
+
+    def __str__(self):
+        return self.text
+
+    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.")
+
+    def to_dict(self, add_edsl_version=True):
+        d = {
+            "name": self.name,
+            "text": self.text,
+            "edsl_class_name": "Instruction",
+            "preamble": self.preamble,
+        }
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Instruction"
+        return d
+
+    def add_question(self, question) -> "Survey":
+        from edsl import Survey
+
+        return Survey([self, question])
+
+    def __hash__(self) -> int:
+        """Return a hash of the question."""
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self.to_dict(add_edsl_version=False))
+
+    @classmethod
+    @remove_edsl_version
+    def from_dict(cls, data):
+        return cls(
+            data["name"],
+            data["text"],
+            data.get("preamble", "You were given the following instructions:"),
+        )

edsl/surveys/instructions/InstructionCollection.py

@@ -1,77 +1,77 @@
-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
-
-
-class InstructionCollection(UserDict):
-    def __init__(
-        self,
-        instruction_names_to_instruction: Dict[str, Instruction],
-        questions: List[QuestionBase],
-    ):
-        self.instruction_names_to_instruction = instruction_names_to_instruction
-        self.questions = questions
-        data = {}
-        for question in self.questions:
-            # just add both the question and the question name
-            data[question.name] = list(self.relevant_instructions(question))
-            # data[question] = list(self.relevant_instructions(question))
-        super().__init__(data)
-
-    def __getitem__(self, key):
-        # in case the person uses question instead of the name
-        if isinstance(key, QuestionBase):
-            key = key.name
-        return self.data[key]
-
-    @property
-    def question_names(self):
-        return [q.name for q in self.questions]
-
-    def question_index(self, question_name):
-        return self.question_names.index(question_name)
-
-    def _entries_before(
-        self, question_name
-    ) -> tuple[List[Instruction], List[ChangeInstruction]]:
-        if question_name not in self.question_names:
-            raise ValueError(
-                f"Question name not found in the list of questions: got '{question_name}'; list is {self.question_names}"
-            )
-        instructions, changes = [], []
-
-        index = self.question_index(question_name)
-        for instruction in self.instruction_names_to_instruction.values():
-            if instruction.pseudo_index < index:
-                if isinstance(instruction, Instruction):
-                    instructions.append(instruction)
-                elif isinstance(instruction, ChangeInstruction):
-                    changes.append(instruction)
-        return instructions, changes
-
-    def relevant_instructions(
-        self, question: Union[str, QuestionBase]
-    ) -> Generator[Instruction, None, None]:
-        ## Find all the questions that are after a given instruction
-        if isinstance(question, str):
-            question_name = question
-        elif isinstance(question, QuestionBase):
-            question_name = question.name
-
-        instructions_before, changes_before = self._entries_before(question_name)
-        keep_list = []
-        drop_list = []
-        for change in changes_before:
-            keep_list.extend(change.keep)
-            drop_list.extend(change.drop)
-
-        for instruction in instructions_before:
-            if instruction.name in keep_list or instruction.name not in drop_list:
-                yield instruction
-
-    def __len__(self):
-        return len(self.instruction_names_to_instruction)
+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
+
+
+class InstructionCollection(UserDict):
+    def __init__(
+        self,
+        instruction_names_to_instruction: Dict[str, Instruction],
+        questions: List[QuestionBase],
+    ):
+        self.instruction_names_to_instruction = instruction_names_to_instruction
+        self.questions = questions
+        data = {}
+        for question in self.questions:
+            # just add both the question and the question name
+            data[question.name] = list(self.relevant_instructions(question))
+            # data[question] = list(self.relevant_instructions(question))
+        super().__init__(data)
+
+    def __getitem__(self, key):
+        # in case the person uses question instead of the name
+        if isinstance(key, QuestionBase):
+            key = key.name
+        return self.data[key]
+
+    @property
+    def question_names(self):
+        return [q.name for q in self.questions]
+
+    def question_index(self, question_name):
+        return self.question_names.index(question_name)
+
+    def _entries_before(
+        self, question_name
+    ) -> tuple[List[Instruction], List[ChangeInstruction]]:
+        if question_name not in self.question_names:
+            raise ValueError(
+                f"Question name not found in the list of questions: got '{question_name}'; list is {self.question_names}"
+            )
+        instructions, changes = [], []
+
+        index = self.question_index(question_name)
+        for instruction in self.instruction_names_to_instruction.values():
+            if instruction.pseudo_index < index:
+                if isinstance(instruction, Instruction):
+                    instructions.append(instruction)
+                elif isinstance(instruction, ChangeInstruction):
+                    changes.append(instruction)
+        return instructions, changes
+
+    def relevant_instructions(
+        self, question: Union[str, QuestionBase]
+    ) -> Generator[Instruction, None, None]:
+        ## Find all the questions that are after a given instruction
+        if isinstance(question, str):
+            question_name = question
+        elif isinstance(question, QuestionBase):
+            question_name = question.name
+
+        instructions_before, changes_before = self._entries_before(question_name)
+        keep_list = []
+        drop_list = []
+        for change in changes_before:
+            keep_list.extend(change.keep)
+            drop_list.extend(change.drop)
+
+        for instruction in instructions_before:
+            if instruction.name in keep_list or instruction.name not in drop_list:
+                yield instruction
+
+    def __len__(self):
+        return len(self.instruction_names_to_instruction)

edsl/templates/error_reporting/base.html

@@ -1,24 +1,24 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Exception Details</title>
-    <style>
-    {{ css }}
-    </style>
-
-    <script>
-    {{ javascript }}
-    </script>
-
-</head>
-<body>
-    {% include 'overview.html' %}
-    {% include 'exceptions_by_type.html' %}
-    {% include 'exceptions_by_model.html' %}
-    {% include 'exceptions_by_question_name.html' %}
-    {% include 'interviews.html' %}
-    {% include 'performance_plot.html' %}
-</body>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Exception Details</title>
+    <style>
+    {{ css }}
+    </style>
+
+    <script>
+    {{ javascript }}
+    </script>
+
+</head>
+<body>
+    {% include 'overview.html' %}
+    {% include 'exceptions_by_type.html' %}
+    {% include 'exceptions_by_model.html' %}
+    {% include 'exceptions_by_question_name.html' %}
+    {% include 'interviews.html' %}
+    {% include 'performance_plot.html' %}
+</body>
 </html>