edsl 0.1.33__py3-none-any.whl → 0.1.33.dev1__py3-none-any.whl

edsl/results/DatasetTree.py

@@ -1,145 +0,0 @@
-from typing import Dict, List, Any, Optional
-from docx import Document
-from docx.shared import Inches, Pt
-from docx.enum.text import WD_ALIGN_PARAGRAPH
-from docx.enum.style import WD_STYLE_TYPE
-
-
-class TreeNode:
-    def __init__(self, key=None, value=None):
-        self.key = key
-        self.value = value
-        self.children = {}
-
-
-class Tree:
-    def __init__(self, data: "Dataset"):
-        d = {}
-        for entry in data:
-            d.update(entry)
-        self.data = d
-        self.root = None
-
-    def unique_values_by_keys(self) -> dict:
-        unique_values = {}
-        for key, values in self.data.items():
-            unique_values[key] = list(set(values))
-        return unique_values
-
-    def construct_tree(self, node_order: Optional[List[str]] = None):
-        # Validate node_order
-        if node_order is None:
-            unique_values = self.unique_values_by_keys()
-            # Sort keys by number of unique values
-            node_order = sorted(
-                unique_values, key=lambda k: len(unique_values[k]), reverse=True
-            )
-        else:
-            if not set(node_order).issubset(set(self.data.keys())):
-                invalid_keys = set(node_order) - set(self.data.keys())
-                raise ValueError(f"Invalid keys in node_order: {invalid_keys}")
-
-        self.root = TreeNode()
-
-        for i in range(len(self.data[node_order[0]])):
-            current = self.root
-            for level in node_order[:-1]:
-                value = self.data[level][i]
-                if value not in current.children:
-                    current.children[value] = TreeNode(key=level, value=value)
-                current = current.children[value]
-
-            leaf_key = node_order[-1]
-            leaf_value = self.data[leaf_key][i]
-            if leaf_value not in current.children:
-                current.children[leaf_value] = TreeNode(key=leaf_key, value=leaf_value)
-
-    def print_tree(
-        self, node: Optional[TreeNode] = None, level: int = 0, print_keys: bool = False
-    ):
-        if node is None:
-            node = self.root
-            if node is None:
-                print("Tree has not been constructed yet.")
-                return
-
-        if node.value is not None:
-            if print_keys and node.key is not None:
-                print("  " * level + f"{node.key}: {node.value}")
-            else:
-                print("  " * level + str(node.value))
-        for child in node.children.values():
-            self.print_tree(child, level + 1, print_keys)
-
-    def to_docx(self, filename: str):
-        doc = Document()
-
-        # Create styles for headings
-        for i in range(1, 10):  # Up to 9 levels of headings
-            style_name = f"Heading {i}"
-            if style_name not in doc.styles:
-                doc.styles.add_style(style_name, WD_STYLE_TYPE.PARAGRAPH)
-
-        # Get or create the 'Body Text' style
-        if "Body Text" not in doc.styles:
-            body_style = doc.styles.add_style("Body Text", WD_STYLE_TYPE.PARAGRAPH)
-        else:
-            body_style = doc.styles["Body Text"]
-
-        body_style.font.size = Pt(11)
-
-        self._add_to_docx(doc, self.root, 0)
-        doc.save(filename)
-
-    def _add_to_docx(self, doc, node: TreeNode, level: int):
-        if node.value is not None:
-            if level == 0:
-                doc.add_heading(str(node.value), level=level + 1)
-            elif node.children:  # If the node has children, it's not the last level
-                para = doc.add_paragraph(str(node.value))
-                para.style = f"Heading {level+1}"
-            else:  # If the node has no children, it's the last level (body text)
-                para = doc.add_paragraph(str(node.value))
-                para.style = "Body Text"
-
-        # Process child nodes (moved outside the if block)
-        for child in node.children.values():
-            self._add_to_docx(doc, child, level + 1)
-
-
-# Example usage (commented out)
-"""
-from edsl.results.Dataset import Dataset
-
-data = Dataset(
-    [
-        {"continent": ["North America", "Asia", "Europe", "North America", "Asia"]},
-        {"country": ["US", "China", "France", "Canada", "Japan"]},
-        {"city": ["New York", "Beijing", "Paris", "Toronto", "Tokyo"]},
-        {"population": [8419000, 21540000, 2161000, 2930000, 13960000]},
-    ]
-)
-
-tree = Tree(data)
-
-try:
-    tree.construct_tree(["continent", "country", "city", "population"])
-    print("Tree without key names:")
-    tree.print_tree()
-    print("\nTree with key names:")
-    tree.print_tree(print_keys=True)
-except ValueError as e:
-    print(f"Error: {e}")
-
-# Demonstrating validation
-try:
-    tree.construct_tree(["continent", "country", "invalid_key"])
-except ValueError as e:
-    print(f"\nValidation Error: {e}")
-
-tree = Tree(data)
-tree.construct_tree(["continent", "country", "city", "population"])
-tree.print_tree(print_keys=True)
-tree.to_docx("tree_structure.docx")
-print("DocX file 'tree_structure.docx' has been created.")
-"""

edsl/results/Selector.py

@@ -1,118 +0,0 @@
-from typing import Union, List, Dict, Any
-from collections import defaultdict
-from edsl.results.Dataset import Dataset
-
-
-class Selector:
-    def __init__(
-        self,
-        known_data_types: List[str],
-        data_type_to_keys: Dict[str, List[str]],
-        key_to_data_type: Dict[str, str],
-        fetch_list_func,
-        columns: List[str],
-    ):
-        self.known_data_types = known_data_types
-        self._data_type_to_keys = data_type_to_keys
-        self._key_to_data_type = key_to_data_type
-        self._fetch_list = fetch_list_func
-        self.columns = columns
-
-    def select(self, *columns: Union[str, List[str]]) -> "Dataset":
-        columns = self._normalize_columns(columns)
-        to_fetch = self._get_columns_to_fetch(columns)
-        new_data = self._fetch_data(to_fetch)
-        return Dataset(new_data)
-
-    def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
-        if not columns or columns == ("*",) or columns == (None,):
-            return ("*.*",)
-        if isinstance(columns[0], list):
-            return tuple(columns[0])
-        return columns
-
-    def _get_columns_to_fetch(self, columns: tuple) -> Dict[str, List[str]]:
-        to_fetch = defaultdict(list)
-        self.items_in_order = []
-
-        for column in columns:
-            matches = self._find_matching_columns(column)
-            self._validate_matches(column, matches)
-
-            if len(matches) == 1:
-                column = matches[0]
-
-            data_type, key = self._parse_column(column)
-            self._process_column(data_type, key, to_fetch)
-
-        return to_fetch
-
-    def _find_matching_columns(self, partial_name: str) -> list[str]:
-        if "." in partial_name:
-            search_in_list = self.columns
-        else:
-            search_in_list = [s.split(".")[1] for s in self.columns]
-
-        matches = [s for s in search_in_list if s.startswith(partial_name)]
-        return [partial_name] if partial_name in matches else matches
-
-    def _validate_matches(self, column: str, matches: List[str]):
-        if len(matches) > 1:
-            raise ValueError(
-                f"Column '{column}' is ambiguous. Did you mean one of {matches}?"
-            )
-        if len(matches) == 0 and ".*" not in column:
-            raise ValueError(f"Column '{column}' not found in data.")
-
-    def _parse_column(self, column: str) -> tuple[str, str]:
-        if "." in column:
-            return column.split(".")
-        try:
-            return self._key_to_data_type[column], column
-        except KeyError:
-            self._raise_key_error(column)
-
-    def _raise_key_error(self, column: str):
-        import difflib
-
-        close_matches = difflib.get_close_matches(column, self._key_to_data_type.keys())
-        if close_matches:
-            suggestions = ", ".join(close_matches)
-            raise KeyError(
-                f"Column '{column}' not found in data. Did you mean: {suggestions}?"
-            )
-        else:
-            raise KeyError(f"Column {column} not found in data")
-
-    def _process_column(self, data_type: str, key: str, to_fetch: Dict[str, List[str]]):
-        data_types = self._get_data_types_to_return(data_type)
-        found_once = False
-
-        for dt in data_types:
-            relevant_keys = self._data_type_to_keys[dt]
-            for k in relevant_keys:
-                if k == key or key == "*":
-                    found_once = True
-                    to_fetch[dt].append(k)
-                    self.items_in_order.append(f"{dt}.{k}")
-
-        if not found_once:
-            raise ValueError(f"Key {key} not found in data.")
-
-    def _get_data_types_to_return(self, parsed_data_type: str) -> List[str]:
-        if parsed_data_type == "*":
-            return self.known_data_types
-        if parsed_data_type not in self.known_data_types:
-            raise ValueError(
-                f"Data type {parsed_data_type} not found in data. Did you mean one of {self.known_data_types}"
-            )
-        return [parsed_data_type]
-
-    def _fetch_data(self, to_fetch: Dict[str, List[str]]) -> List[Dict[str, Any]]:
-        new_data = []
-        for data_type, keys in to_fetch.items():
-            for key in keys:
-                entries = self._fetch_list(data_type, key)
-                new_data.append({f"{data_type}.{key}": entries})
-
-        return [d for key in self.items_in_order for d in new_data if key in d]

edsl/results/tree_explore.py

@@ -1,115 +0,0 @@
-from collections import defaultdict
-from typing import List, Dict, Any
-import json
-
-
-class FoldableHTMLTableGenerator:
-    def __init__(self, data: List[Dict[str, Any]]):
-        self.data = data
-
-    def tree(self, fold_attributes: List[str], drop: List[str] = None) -> Dict:
-        def nested_dict():
-            return defaultdict(nested_dict)
-
-        result = nested_dict()
-        drop = drop or []  # Use an empty list if drop is None
-
-        for item in self.data:
-            current = result
-            for attr in fold_attributes:
-                current = current[item[attr]]
-
-            row = {
-                k: v
-                for k, v in item.items()
-                if k not in fold_attributes and k not in drop
-            }
-            if "_rows" not in current:
-                current["_rows"] = []
-            current["_rows"].append(row)
-
-        return result
-
-    def generate_html(self, tree, fold_attributes: List[str]) -> str:
-        html_content = """
-        <!DOCTYPE html>
-        <html lang="en">
-        <head>
-            <meta charset="UTF-8">
-            <meta name="viewport" content="width=device-width, initial-scale=1.0">
-            <title>Foldable Nested Table</title>
-            <style>
-                .folding-section { margin-left: 20px; }
-                .fold-button { cursor: pointer; margin: 5px 0; }
-                table { border-collapse: collapse; margin-top: 10px; }
-                th, td { border: 1px solid black; padding: 5px; }
-                .attribute-label { font-weight: bold; }
-            </style>
-        </head>
-        <body>
-            <div id="root"></div>
-            <script>
-            function toggleFold(id) {
-                const element = document.getElementById(id);
-                element.style.display = element.style.display === 'none' ? 'block' : 'none';
-            }
-
-            function createFoldableSection(data, path = [], attributes = %s) {
-                const container = document.createElement('div');
-                container.className = 'folding-section';
-
-                for (const [key, value] of Object.entries(data)) {
-                    if (key === '_rows') {
-                        const table = document.createElement('table');
-                        const headerRow = table.insertRow();
-                        const headers = Object.keys(value[0]);
-                        headers.forEach(header => {
-                            const th = document.createElement('th');
-                            th.textContent = header;
-                            headerRow.appendChild(th);
-                        });
-                        value.forEach(row => {
-                            const tableRow = table.insertRow();
-                            headers.forEach(header => {
-                                const cell = tableRow.insertCell();
-                                cell.textContent = row[header];
-                            });
-                        });
-                        container.appendChild(table);
-                    } else {
-                        const button = document.createElement('button');
-                        const attributeType = attributes[path.length];
-                        button.innerHTML = `<span class="attribute-label">${attributeType}:</span> ${key}`;
-                        button.className = 'fold-button';
-                        const sectionId = `section-${path.join('-')}-${key}`;
-                        button.onclick = () => toggleFold(sectionId);
-                        container.appendChild(button);
-
-                        const section = document.createElement('div');
-                        section.id = sectionId;
-                        section.style.display = 'none';
-                        section.appendChild(createFoldableSection(value, [...path, key], attributes));
-                        container.appendChild(section);
-                    }
-                }
-
-                return container;
-            }
-
-            const treeData = %s;
-            document.getElementById('root').appendChild(createFoldableSection(treeData));
-            </script>
-        </body>
-        </html>
-        """
-
-        return html_content % (json.dumps(fold_attributes), json.dumps(tree))
-
-    def save_html(self, fold_attributes: List[str], filename: str = "output.html"):
-        tree = self.tree(fold_attributes)
-        html_content = self.generate_html(tree, fold_attributes)
-
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write(html_content)
-
-        print(f"HTML file has been generated: {filename}")

edsl/surveys/instructions/ChangeInstruction.py

@@ -1,47 +0,0 @@
-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"])

edsl/surveys/instructions/Instruction.py

@@ -1,34 +0,0 @@
-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):
-        self.name = name
-        self.text = text
-
-    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"}
-
-    @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"])

edsl/surveys/instructions/InstructionCollection.py

@@ -1,77 +0,0 @@
-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 +0,0 @@
-<!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>

edsl/templates/error_reporting/exceptions_by_model.html

@@ -1,35 +0,0 @@
-<h2>Exceptions by Model</h2>
-<table border="1">
-    <thead>
-        <tr>
-            <th>Model</th>
-            <th>Number</th>
-        </tr>
-    </thead>
-    <tbody>
-        {% for model, exceptions in exceptions_by_model.items() %}
-            <tr>
-                <td>{{ model }}</td>
-                <td>{{ exceptions }}</td>
-            </tr>
-        {% endfor %}
-    </tbody>
-</table>
-
-<h2>Exceptions by Service</h2>
-<table border="1">
-    <thead>
-        <tr>
-            <th>Service</th>
-            <th>Number</th>
-        </tr>
-    </thead>
-    <tbody>
-        {% for service, exceptions in exceptions_by_service.items() %}
-            <tr>
-                <td>{{ service }}</td>
-                <td>{{ exceptions }}</td>
-            </tr>
-        {% endfor %}
-    </tbody>
-</table>

edsl/templates/error_reporting/exceptions_by_question_name.html

@@ -1,17 +0,0 @@
-<h2>Exceptions by Question Name</h2>
-<table border="1">
-    <thead>
-        <tr>
-            <th>Question Name</th>
-            <th>Number of Exceptions</th>
-        </tr>
-    </thead>
-    <tbody>
-        {% for question_name, exception_count in exceptions_by_question_name.items() %}
-            <tr>
-                <td>{{ question_name }}</td>
-                <td>{{ exception_count }}</td>
-            </tr>
-        {% endfor %}
-    </tbody>
-</table>

edsl/templates/error_reporting/exceptions_by_type.html

@@ -1,17 +0,0 @@
-<h2>Exceptions by Type</h2>
-<table border="1">
-    <thead>
-        <tr>
-            <th>Exception Type</th>
-            <th>Number</th>
-        </tr>
-    </thead>
-    <tbody>
-        {% for exception_type, exceptions in exceptions_by_type.items() %}
-            <tr>
-                <td>{{ exception_type }}</td>
-                <td>{{ exceptions }}</td>
-            </tr>
-        {% endfor %}
-    </tbody>
-</table>