edsl 0.1.47__py3-none-any.whl → 0.1.48__py3-none-any.whl

edsl/surveys/SurveyQualtricsImport.py

@@ -1,284 +0,0 @@
-import json
-import html
-import re
-
-from edsl import Question
-from edsl import Survey
-
-qualtrics_codes = {
-    "TE": "free_text",
-    "MC": "multiple_choice",
-    "Matrix": "matrix",
-    "DB": "instruction",  # not quite right, but for now
-    "Timing": "free_text",  # not quite right, but for now
-}
-# TE (Text Entry): Allows respondents to input a text response.
-# MC (Multiple Choice): Provides respondents with a list of options to choose from.
-# DB (Descriptive Text or Information): Displays text or information without requiring a response.
-# Matrix: A grid-style question where respondents can evaluate multiple items using the same set of response options.
-
-
-def clean_html(raw_html):
-    # Unescape HTML entities
-    clean_text = html.unescape(raw_html)
-    # Remove HTML tags
-    clean_text = re.sub(r"<.*?>", "", clean_text)
-    # Replace non-breaking spaces with regular spaces
-    clean_text = clean_text.replace("\xa0", " ")
-    # Optionally, strip leading/trailing spaces
-    clean_text = clean_text.strip()
-    return clean_text
-
-
-class QualtricsQuestion:
-    def __init__(self, question_json, debug=False):
-        self.debug = debug
-        self.question_json = question_json
-        if self.element != "SQ":
-            raise ValueError("Invalid question element type")
-
-    @property
-    def element(self):
-        return self.question_json["Element"]
-
-    @property
-    def selector(self):
-        return self.question_json.get("Selector", None)
-
-    @property
-    def question_name(self):
-        return self.question_json["PrimaryAttribute"]
-
-    @property
-    def question_text(self):
-        return clean_html(self.question_json["Payload"]["QuestionText"])
-
-    @property
-    def raw_question_type(self):
-        return self.question_json["Payload"]["QuestionType"]
-
-    @property
-    def question_type(self):
-        q_type = qualtrics_codes.get(self.raw_question_type, None)
-        if q_type is None:
-            print(f"Unknown question type: {self.raw_question_type}")
-            return None
-        return q_type
-
-    @property
-    def choices(self):
-        if "Choices" in self.question_json["Payload"]:
-            return [
-                choice["Display"]
-                for choice in self.question_json["Payload"]["Choices"].values()
-            ]
-        return None
-
-    @property
-    def answers(self):
-        if "Answers" in self.question_json["Payload"]:
-            return [
-                choice["Display"]
-                for choice in self.question_json["Payload"]["Choices"].values()
-            ]
-        return None
-
-    def to_edsl(self):
-        if self.question_type == "instruction":
-            from edsl import Instruction
-
-            return [Instruction(text=self.question_text, name=self.question_name)]
-
-        if self.question_type == "free_text":
-            try:
-                q = Question(
-                    **{
-                        "question_type": self.question_type,
-                        "question_text": self.question_text,
-                        "question_name": self.question_name,
-                    }
-                )
-                return [q]
-            except Exception as e:
-                return []
-
-        if self.question_type == "multiple_choice":
-            # Let's figure of it it's actually a checkbox question
-            if self.selector == "MAVR" or self.selector == "MULTIPLE":
-                try:
-                    q = Question(
-                        **{
-                            "question_type": "checkbox",
-                            "question_text": self.question_text,
-                            "question_name": self.question_name,
-                            "question_options": self.choices,
-                        }
-                    )
-                    return [q]
-                except Exception as e:
-                    return []
-
-            # maybe it's a linear scale!
-            if "<br>" in self.choices[0]:
-                option_labels = {}
-                question_options = []
-                for choice in self.choices:
-                    if "<br>" in choice:
-                        option_label, question_option = choice.split("<br>")
-                        option_labels[int(question_option)] = option_label
-                        question_options.append(int(question_option))
-                    else:
-                        question_options.append(int(choice))
-                try:
-                    q = Question(
-                        **{
-                            "question_type": "linear_scale",
-                            "question_text": self.question_text,
-                            "question_name": self.question_name,
-                            "question_options": question_options,
-                            "option_labels": option_labels,
-                        }
-                    )
-                    return [q]
-                except Exception as e:
-                    if self.debug:
-                        raise e
-                    else:
-                        print(e)
-                        return []
-
-            try:
-                q = Question(
-                    **{
-                        "question_type": self.question_type,
-                        "question_text": self.question_text,
-                        "question_name": self.question_name,
-                        "question_options": self.choices,
-                    }
-                )
-                return [q]
-            except Exception as e:
-                return []
-
-        if self.question_type == "matrix":
-            questions = []
-            for index, choice in enumerate(self.choices):
-                try:
-                    q = Question(
-                        **{
-                            "question_type": "multiple_choice",
-                            "question_text": self.question_text + f" ({choice})",
-                            "question_name": self.question_name + f"_{index}",
-                            "question_options": self.answers,
-                        }
-                    )
-                    questions.append(q)
-                except Exception as e:
-                    continue
-
-            return questions
-
-        raise ValueError(f"Invalid question type: {self.question_type}")
-
-
-class SurveyQualtricsImport:
-    def __init__(self, qsf_file_name: str):
-        self.qsf_file_name = qsf_file_name
-        self.question_data = self.extract_questions_from_json()
-
-    def create_survey(self):
-        questions = []
-        for qualtrics_questions in self.question_data:
-            questions.extend(qualtrics_questions.to_edsl())
-        return Survey(questions)
-
-    @property
-    def survey_data(self):
-        with open(self.qsf_file_name, "r") as f:
-            survey_data = json.load(f)
-        return survey_data
-
-    def extract_questions_from_json(self):
-        questions = self.survey_data["SurveyElements"]
-
-        extracted_questions = []
-
-        for question in questions:
-            if question["Element"] == "SQ":
-                extracted_questions.append(QualtricsQuestion(question))
-
-        return extracted_questions
-
-    def extract_blocks_from_json(self):
-        blocks = []
-
-        for element in self.survey_data["SurveyElements"]:
-            if element["Element"] == "BL":
-                for block_payload in element["Payload"]:
-                    block_elements = [
-                        BlockElement(be["Type"], be["QuestionID"])
-                        for be in block_payload["BlockElements"]
-                    ]
-                    options_data = block_payload.get("Options", {})
-                    options = BlockOptions(
-                        options_data.get("BlockLocking", "false"),
-                        options_data.get("RandomizeQuestions", "false"),
-                        options_data.get("BlockVisibility", "Collapsed"),
-                    )
-
-                    block = SurveyBlock(
-                        block_payload["Type"],
-                        block_payload["Description"],
-                        block_payload["ID"],
-                        block_elements,
-                        options,
-                    )
-                    blocks.append(block)
-
-        return blocks
-
-
-class SurveyBlock:
-    def __init__(self, block_type, description, block_id, block_elements, options):
-        self.block_type = block_type
-        self.description = description
-        self.block_id = block_id
-        self.block_elements = block_elements
-        self.options = options
-
-    def __repr__(self):
-        return f"SurveyBlock(type={self.block_type}, description={self.description}, id={self.block_id})"
-
-
-class BlockElement:
-    def __init__(self, element_type, question_id):
-        self.element_type = element_type
-        self.question_id = question_id
-
-    def __repr__(self):
-        return f"BlockElement(type={self.element_type}, question_id={self.question_id})"
-
-
-class BlockOptions:
-    def __init__(self, block_locking, randomize_questions, block_visibility):
-        self.block_locking = block_locking
-        self.randomize_questions = randomize_questions
-        self.block_visibility = block_visibility
-
-    def __repr__(self):
-        return (
-            f"BlockOptions(block_locking={self.block_locking}, "
-            f"randomize_questions={self.randomize_questions}, "
-            f"block_visibility={self.block_visibility})"
-        )
-
-
-if __name__ == "__main__":
-    survey_creator = SurveyQualtricsImport("example.qsf")
-    # print(survey_creator.question_data)
-    # survey = survey_creator.create_survey()
-    # info = survey.push()
-    # print(info)
-    # questions = survey.extract_questions_from_json()
-    # for question in questions:
-    #    print(question)

edsl/surveys/SurveyToApp.py

@@ -1,141 +0,0 @@
-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/tools/__init__.py

@@ -1 +0,0 @@
-from edsl.tools.plotting import barchart

edsl/tools/clusters.py

@@ -1,192 +0,0 @@
-import json
-import numpy as np
-from sklearn.cluster import KMeans
-from sklearn.manifold import TSNE
-from sklearn.decomposition import PCA
-from IPython.display import display_html
-
-
-def compute_tsne(embeddings, cluster_labels, text_labels):
-    """
-    Compute t-SNE on embedding vectors.
-
-    Parameters:
-    embeddings (np.ndarray): The embedding vectors.
-    cluster_labels (np.ndarray): Cluster labels for each embedding.
-    text_labels (list): Text labels for each embedding.
-
-    Returns:
-    list: List of dictionaries with x, y coordinates, cluster labels, and text labels.
-    """
-    tsne = TSNE(n_components=2, random_state=42)
-    tsne_results = tsne.fit_transform(embeddings)
-    data = [
-        {
-            "x": float(tsne_results[i, 0]),
-            "y": float(tsne_results[i, 1]),
-            "cluster_label": str(cluster_labels[i]),
-            "text_label": text_labels[i],
-        }
-        for i in range(len(cluster_labels))
-    ]
-    return data
-
-
-def compute_pca(embeddings, cluster_labels, text_labels):
-    """
-    Compute PCA on embedding vectors.
-
-    Parameters:
-    embeddings (np.ndarray): The embedding vectors.
-    cluster_labels (np.ndarray): Cluster labels for each embedding.
-    text_labels (list): Text labels for each embedding.
-
-    Returns:
-    list: List of dictionaries with x, y coordinates, cluster labels, and text labels.
-    """
-    pca = PCA(n_components=2)
-    pca_results = pca.fit_transform(embeddings)
-    data = [
-        {
-            "x": float(pca_results[i, 0]),
-            "y": float(pca_results[i, 1]),
-            "cluster_label": str(cluster_labels[i]),
-            "text_label": text_labels[i],
-        }
-        for i in range(len(cluster_labels))
-    ]
-    return data
-
-
-def plot(embeddings, text_labels, n_clusters=5, method="tsne"):
-    """
-    Perform k-means clustering and plot results in a Jupyter notebook using D3.js.
-
-    Parameters:
-    embeddings (np.ndarray): The embedding vectors.
-    text_labels (list): Text labels for each embedding.
-    n_clusters (int): The number of clusters to form.
-    method (str): The dimensionality reduction method to use ('tsne' or 'pca').
-    """
-    # Perform k-means clustering
-    kmeans = KMeans(n_clusters=n_clusters, random_state=42)
-    cluster_labels = kmeans.fit_predict(embeddings)
-
-    # Compute dimensionality reduction
-    if method == "tsne":
-        data = compute_tsne(embeddings, cluster_labels, text_labels)
-    elif method == "pca":
-        data = compute_pca(embeddings, cluster_labels, text_labels)
-    else:
-        raise ValueError("Invalid method. Choose 'tsne' or 'pca'.")
-
-    # Convert data to JSON
-    data_json = json.dumps(data)
-
-    # HTML content with embedded data
-    html_content = f"""
-    <!DOCTYPE html>
-    <html lang="en">
-    <head>
-        <meta charset="UTF-8">
-        <title>t-SNE/PCA Plot with D3.js</title>
-        <script src="https://d3js.org/d3.v6.min.js"></script>
-        <style>
-            .tooltip {{
-                position: absolute;
-                text-align: center;
-                width: auto;
-                height: auto;
-                padding: 2px;
-                font: 12px sans-serif;
-                background: lightsteelblue;
-                border: 0px;
-                border-radius: 8px;
-                pointer-events: none;
-            }}
-            .dot {{
-                stroke: #000;
-                stroke-width: 0.5;
-            }}
-        </style>
-    </head>
-    <body>
-        <svg width="600" height="600"></svg>
-
-        <script>
-            // Embedded data
-            const data = {data_json};
-
-            const svg = d3.select("svg"),
-                width = +svg.attr("width"),
-                height = +svg.attr("height");
-
-            // Set up scales
-            const x = d3.scaleLinear()
-                .domain(d3.extent(data, d => d.x))
-                .range([0, width]);
-            
-            const y = d3.scaleLinear()
-                .domain(d3.extent(data, d => d.y))
-                .range([height, 0]);
-
-            // Set up color scale
-            const color = d3.scaleOrdinal(d3.schemeCategory10);
-
-            // Create tooltip
-            const tooltip = d3.select("body").append("div")
-                .attr("class", "tooltip")
-                .style("opacity", 0);
-
-            // Create circles for each point
-            svg.selectAll("circle")
-                .data(data)
-                .enter().append("circle")
-                .attr("cx", d => x(d.x))
-                .attr("cy", d => y(d.y))
-                .attr("r", 5)
-                .attr("class", "dot")
-                .style("fill", d => color(d.cluster_label))
-                .on("mouseover", function(event, d) {{
-                    tooltip.transition()
-                        .duration(200)
-                        .style("opacity", .9);
-                    tooltip.html(d.text_label)
-                        .style("left", (event.pageX + 5) + "px")
-                        .style("top", (event.pageY - 28) + "px");
-                }})
-                .on("mouseout", function(d) {{
-                    tooltip.transition()
-                        .duration(500)
-                        .style("opacity", 0);
-                }});
-        </script>
-    </body>
-    </html>
-    """
-
-    # Write HTML content to a temporary file
-    html_file = "tsne_pca_plot.html"
-    with open(html_file, "w") as file:
-        file.write(html_content)
-
-    # Display the HTML content in an iframe within a Jupyter notebook
-    display_html(
-        f'<iframe src="{html_file}" width="600" height="600"></iframe>', raw=True
-    )
-
-
-# Example usage
-if __name__ == "__main__":
-    # Generate some sample data (embedding vectors)
-    np.random.seed(42)
-    embedding_vectors = np.random.rand(
-        100, 50
-    )  # 100 samples with 50-dimensional embeddings
-    text_labels = [f"Text {i}" for i in range(100)]  # Sample text labels
-
-    # Plot the clusters using t-SNE
-    plot(embedding_vectors, text_labels, n_clusters=5, method="tsne")
-
-    # Plot the clusters using PCA
-    plot(embedding_vectors, text_labels, n_clusters=5, method="pca")

edsl/tools/embeddings.py

@@ -1,27 +0,0 @@
-import openai
-from dotenv import load_dotenv
-import os
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Get the OpenAI API key from the environment variable
-openai.api_key = os.getenv("OPENAI_API_KEY")
-
-from openai import Client
-
-
-def get_embeddings(texts):
-    """
-    Get embeddings for a list of texts using OpenAI API.
-
-    Args:
-        texts (list of str): List of strings to get embeddings for.
-
-    Returns:
-        list of list of float: List of embeddings.
-    """
-    client = Client()
-    response = client.embeddings.create(input=texts, model="text-embedding-ada-002")
-    embeddings = [item.embedding for item in response.data]
-    return embeddings