themefinder 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

themefinder/prompts/theme_mapping.txt

@@ -1,12 +1,12 @@
 {system_prompt}
 
-Your job is to help identify which topics come up in responses to a question.
+Your job is to help identify which topics come up in free_text_responses to a question.
 
 You will be given:
     - a QUESTION that has been asked
-    - a TOPIC LIST of topics that are known to be present in responses to this question. These will be structured as follows:
+    - a TOPIC LIST of topics that are known to be present in free_text_responses to this question. These will be structured as follows:
         {{'topic_id': 'topic_description}}
-    - a list of RESPONSES to the question. These will be structured as follows:
+    - a list of FREE_TEXT_RESPONSES to the question. These will be structured as follows:
         {{'response_id': 'free text response'}}
 
 Your task is to analyze each response and decide which topics are present. Guidelines:
@@ -14,10 +14,11 @@ Your task is to analyze each response and decide which topics are present. Guide
     - A response doesn't need to exactly match the language used in the TOPIC LIST, it should be considered a match if it expresses a similar sentiment.
     - You must use the alphabetic 'topic_id' to indicate which topic you have assigned. Do not use the full topic description
     - Each response can be assigned to multiple topics if it matches more than one topic from the TOPIC LIST.
+    - Each topic can only be assigned once per response, if the topic is mentioned more than once use the first mention for reasoning and stance.
     - There is no limit on how many topics can be assigned to a response.
     - For each assignment provide a single rationale for why you have chosen the label.
     - For each topic identified in a response, indicate whether the response expresses a positive or negative stance toward that topic (options: 'POSITIVE' or 'NEGATIVE')
-    - You MUST use either 'POSTIVE' or 'NEGATIVE'
+    - You MUST use either 'POSITIVE' or 'NEGATIVE'
     - The order of reasons and stances must align with the order of labels (e.g., stance_a applies to topic_a)
 
 You MUST include every response ID in the output.
@@ -25,24 +26,6 @@ If the response can not be labelled return empty sections where appropriate but
 with the correct response ID for each input object.
 You must only return the alphabetic topic_ids in the labels section.
 
-The final output should be in the following JSON format:
-
-{{
-  "responses": [
-    {{
-      "response_id": response_id_1,
-      "reasons": ["reason_a", "reason_b"],
-      "labels": ["topic_a", "topic_b"],
-      "stances": ["stance_a", "stance_b"],
-    }},
-    {{
-      "response_id": response_id_2,
-      "reasons": ["reason_c"],
-      "labels": ["topic_c"],
-      "stances": ["stance_c"],
-    }}
-  ]
-}}
 
 QUESTION:
 
@@ -52,6 +35,6 @@ TOPIC LIST:
 
 {refined_themes}
 
-RESPONSES:
+FREE_TEXT_RESPONSES:
 
 {responses}

themefinder/prompts/theme_refinement.txt

@@ -6,9 +6,12 @@ You are tasked with refining a list of topics generated from responses to a ques
 You will receive a list of TOPICS. These topics explicitly tie opinions to whether a person agrees or disagrees with the question.
 
 ## Output
-You will produce a list of CLEAR STANCE TOPICS based on the input. Each topic should have two parts:
-1. A brief, clear topic label (3-7 words)
-2. A more detailed topic description (1-2 sentences)
+You will produce a list of CLEAR STANCE TOPICS based on the input. Each topic should have four parts:
+1. A topic_id that is an uppercase letter (starting from 'A', for the 27th element use AA)
+2. A brief, clear topic label (3-7 words)
+3. A more detailed topic description (1-2 sentences)
+4. The source_topic_count field should be included for each topic and should reflect the number of original source topics that were merged to create this refined topic. If multiple source topics were combined, sum their individual counts. If only one source topic was used, simply retain its original count value.
+
 
 ## Guidelines
 
@@ -46,20 +49,8 @@ You will produce a list of CLEAR STANCE TOPICS based on the input. Each topic sh
    b. Create a neutral, concise topic label.
    c. Write a more detailed description that provides context without taking sides.
 4. Review the entire list to ensure distinctiveness and adjust as needed.
-5. Assign each output topic a topic_id a single uppercase letters (starting from 'A', for the 27th element use AA)
+5. Assign each output topic a topic_id that is an uppercase letter (starting from 'A', for the 27th element use AA)
 6. Combine the topic label and description with a colon separator
 
-Return your output in the following JSON format:
-{{
-   "responses": [
-       {{"topic_id": "A", "topic": "{{topic label 1}}: {{topic description 1}}", "source_topic_count": {{count1}}}},
-       {{"topic_id": "B", "topic": "{{topic label 2}}: {{topic description 2}}", "source_topic_count": {{count2}}}},
-       {{"topic_id": "C", "topic": "{{topic label 3}}: {{topic description 3}}", "source_topic_count": {{count3}}}},
-      // Additional topics as necessary
-   ]
-}}
-
-
-
 TOPICS:
 {responses}

themefinder/prompts/theme_target_alignment.txt

@@ -10,17 +10,9 @@ Requirements:
 - Each consolidated theme should capture all relevant information from its source themes
 - Final descriptions should be concise but thorough
 - The merged themes should be distinct from each other with minimal overlap
+- The source_topic_count field should be included for each theme and represent the sum of all source themes that were combined to create it
+- You cannot return more than {target_n_themes}
 
-Return your output in the following JSON format:
-
-{{
-   "responses": [
-       {{"topic_id": "A", "topic": "{{topic label 1}}: {{topic description 1}}"}},
-       {{"topic_id": "B", "topic": "{{topic label 2}}: {{topic description 2}}"}},
-       {{"topic_id": "C", "topic": "{{topic label 3}}: {{topic description 3}}"}},
-      // Additional topics as necessary
-   ]
-}}
 
 Themes to analyze: 
 {responses}

themefinder/theme_clustering_agent.py

@@ -0,0 +1,332 @@
+"""Theme clustering agent for hierarchical topic organization.
+
+This module provides the ThemeClusteringAgent class for performing iterative
+hierarchical clustering of topics using a language model.
+"""
+
+import json
+import logging
+from typing import Dict, List, Any
+
+import pandas as pd
+from langchain.schema.runnable import Runnable
+from tenacity import (
+    before,
+    before_sleep_log,
+    retry,
+    stop_after_attempt,
+    wait_random_exponential,
+)
+
+from .models import ThemeNode
+from .llm_batch_processor import load_prompt_from_file
+from .themefinder_logging import logger
+
+
+class ThemeClusteringAgent:
+    """Agent for performing hierarchical clustering of topics using language models.
+
+    This class manages the iterative process of merging similar topics into a
+    hierarchical structure using an LLM to identify semantic relationships and
+    create meaningful parent-child topic relationships.
+
+    Attributes:
+        llm: Language model configured with structured output for clustering
+        themes: Dictionary mapping topic IDs to ThemeNode objects
+        active_themes: Set of topic IDs that are currently active for clustering
+        current_iteration: Current iteration number in the clustering process
+    """
+
+    def __init__(self, llm: Runnable, themes: List[ThemeNode]) -> None:
+        """Initialize the clustering agent with an LLM and initial themes.
+
+        Args:
+            llm: Language model instance configured with structured output
+                for HierarchicalClusteringResponse
+            themes: List of ThemeNode objects to be clustered
+        """
+        self.llm = llm
+        self.themes: Dict[str, ThemeNode] = {}
+        for theme in themes:
+            self.themes[theme.topic_id] = theme
+        self.active_themes = set(self.themes.keys())
+        self.current_iteration = 0
+
+    def _format_prompt(self) -> str:
+        """Format the clustering prompt with current active themes.
+
+        Creates a JSON representation of all currently active themes and
+        formats them into the clustering prompt template.
+
+        Returns:
+            str: Formatted prompt string ready for LLM processing
+        """
+        themes_for_prompt = []
+        for active_id in self.active_themes:
+            theme_dict = {
+                "topic_id": self.themes[active_id].topic_id,
+                "topic_label": self.themes[active_id].topic_label,
+                "topic_description": self.themes[active_id].topic_description,
+            }
+            themes_for_prompt.append(theme_dict)
+        themes_json = json.dumps(themes_for_prompt, indent=2)
+
+        # Load the clustering prompt template
+        prompt_template = load_prompt_from_file("agentic_theme_clustering")
+        return prompt_template.format(
+            themes_json=themes_json, iteration=self.current_iteration
+        )
+
+    @retry(
+        wait=wait_random_exponential(min=1, max=2),
+        stop=stop_after_attempt(3),
+        before=before.before_log(logger=logger, log_level=logging.DEBUG),
+        before_sleep=before_sleep_log(logger, logging.ERROR),
+        reraise=True,
+    )
+    def cluster_iteration(self) -> None:
+        """Perform one iteration of hierarchical theme clustering.
+
+        Uses the configured LLM to identify semantically similar themes
+        and merge them into parent themes. Updates the theme hierarchy
+        and active theme set based on the clustering results.
+
+        The method includes retry logic to handle transient API failures
+        and will automatically retry up to 3 times with exponential backoff.
+
+        Side Effects:
+            - Creates new parent ThemeNode objects in self.themes
+            - Updates parent_id relationships for child themes
+            - Modifies self.active_themes set
+            - Increments self.current_iteration
+        """
+        prompt = self._format_prompt()
+        response = self.llm.invoke(prompt)
+        # The response is already a parsed dictionary when using with_structured_output
+        result = response
+        for i, parent in enumerate(result["parent_themes"]):
+            new_theme_id = f"{chr(65 + i)}_{self.current_iteration}"
+            children = [c for c in parent["children"] if c in self.active_themes]
+            for child in children:
+                self.themes[child].parent_id = new_theme_id
+            total_source_count = sum(
+                self.themes[child_id].source_topic_count for child_id in children
+            )
+            new_theme = ThemeNode(
+                topic_id=new_theme_id,
+                topic_label=parent["topic_label"],
+                topic_description=parent["topic_description"],
+                source_topic_count=total_source_count,
+                children=children,
+            )
+            self.themes[new_theme_id] = new_theme
+            self.active_themes.add(new_theme_id)
+            for child in children:
+                self.active_themes.remove(child)
+        self.current_iteration += 1
+
+    def cluster_themes(
+        self, max_iterations: int = 5, target_themes: int = 5
+    ) -> pd.DataFrame:
+        """Perform hierarchical clustering to reduce themes to target number.
+
+        Iteratively merges similar themes using the clustering agent until
+        either the maximum iterations is reached or the target number of
+        themes is achieved. Creates a root node to represent the complete
+        hierarchy.
+
+        Args:
+            max_iterations: Maximum number of clustering iterations to perform
+            target_themes: Target number of themes to cluster down to
+
+        Returns:
+            pd.DataFrame: DataFrame containing all theme nodes (excluding root)
+                with their hierarchical relationships and metadata
+        """
+        logger.info(f"Starting clustering with {len(self.active_themes)} active themes")
+        while (
+            self.current_iteration <= max_iterations
+            and len(self.active_themes) > target_themes
+        ):
+            self.cluster_iteration()
+            logger.info(
+                f"After {self.current_iteration} iterations {len(self.active_themes)} active themes remaining"
+            )
+        root_node = ThemeNode(
+            topic_id="0",
+            topic_label="All Topics",
+            topic_description="",
+            source_topic_count=sum(
+                self.themes[theme_id].source_topic_count
+                for theme_id in self.active_themes
+            ),
+            children=list(self.active_themes),
+        )
+        self.themes["0"] = root_node
+        for theme in self.active_themes:
+            self.themes[theme].parent_id = "0"
+
+        # Convert all themes (except root) to DataFrame
+        theme_nodes_dicts = [
+            node.model_dump() for node in self.themes.values() if node.topic_id != "0"
+        ]
+        return pd.DataFrame(theme_nodes_dicts)
+
+    def convert_themes_to_tree_json(self) -> str:
+        """Convert themes into a hierarchical JSON structure for visualization.
+
+        Creates a nested JSON structure starting from the root node (ID '0')
+        that represents the complete theme hierarchy. Each node includes
+        metadata and references to its children.
+
+        Returns:
+            str: JSON string representing the hierarchical tree structure
+                suitable for JavaScript tree visualization libraries
+        """
+
+        def build_tree(node: ThemeNode) -> Dict[str, Any]:
+            return {
+                "id": node.topic_id,
+                "name": node.topic_label,
+                "description": node.topic_description,
+                "value": node.source_topic_count,
+                "children": [
+                    build_tree(self.themes[child_id])
+                    for child_id in node.children
+                    if child_id in self.themes
+                ],
+            }
+
+        tree_data = build_tree(self.themes["0"])
+        return json.dumps(tree_data, indent=2)
+
+    def select_significant_themes(
+        self, significance_threshold: int, total_responses: int
+    ) -> Dict[str, Any]:
+        """Select significant themes using depth-first traversal.
+
+        Performs a depth-first search on the theme hierarchy to identify
+        themes that meet the significance threshold. Prioritizes leaf nodes
+        when possible, but selects parent nodes when children don't meet
+        the threshold.
+
+        Args:
+            significance_threshold: Minimum source_topic_count for significance
+            total_responses: Total number of responses across all themes
+
+        Returns:
+            Dict containing selected theme nodes and metadata
+        """
+        # Track selected nodes
+        selected_nodes: List[Dict[str, Any]] = []
+
+        # Perform the DFS selection
+        self._traverse_tree(self.themes["0"], selected_nodes, significance_threshold)
+
+        # Format the final result
+        result = {"selected_nodes": selected_nodes, "total_responses": total_responses}
+
+        return result
+
+    def _traverse_tree(
+        self,
+        node: ThemeNode,
+        selected_nodes: List[Dict[str, Any]],
+        significance_threshold: int,
+    ) -> bool:
+        """Recursively traverse theme tree to select significant nodes.
+
+        Implements depth-first traversal logic for theme selection:
+        1. For leaf nodes: always select
+        2. For parent nodes: select if no significant children exist
+        3. For significant children: recursively process them
+
+        Args:
+            node: Current ThemeNode being processed
+            selected_nodes: List to accumulate selected theme dictionaries
+            significance_threshold: Minimum source_topic_count for significance
+
+        Returns:
+            bool: True if this node or descendants were selected, False otherwise
+        """
+        # Base case: if node has no children (leaf node)
+        if not node.children:
+            selected_nodes.append(
+                {
+                    "id": node.topic_id,
+                    "name": node.topic_label,
+                    "value": node.source_topic_count,
+                }
+            )
+            return True
+
+        # Check if any children are significant
+        has_significant_children = any(
+            self.themes[child_id].source_topic_count >= significance_threshold
+            for child_id in node.children
+            if child_id in self.themes
+        )
+
+        # If no significant children, select this node
+        if not has_significant_children:
+            selected_nodes.append(
+                {
+                    "id": node.topic_id,
+                    "name": node.topic_label,
+                    "value": node.source_topic_count,
+                }
+            )
+            return True
+
+        # If significant children exist, recursively process them
+        any_selected = False
+        for child_id in node.children:
+            if child_id in self.themes:
+                if self._traverse_tree(
+                    self.themes[child_id], selected_nodes, significance_threshold
+                ):
+                    any_selected = True
+
+        # If none of the children were selected, select this node
+        if not any_selected:
+            selected_nodes.append(
+                {
+                    "id": node.topic_id,
+                    "name": node.topic_label,
+                    "value": node.source_topic_count,
+                }
+            )
+            return True
+
+        return any_selected
+
+    def select_themes(self, significance_percentage: float) -> pd.DataFrame:
+        """Select themes that meet the significance threshold.
+
+        Calculates the significance threshold based on the percentage of total
+        responses and returns only themes that meet or exceed this threshold.
+        Excludes the root node from results.
+
+        Args:
+            significance_percentage: Percentage (0-100) of total responses
+                required for a theme to be considered significant
+
+        Returns:
+            pd.DataFrame: DataFrame containing significant theme data,
+                excluding the root node (topic_id='0')
+        """
+        total_responses = self.themes["0"].source_topic_count
+        # Convert percentage to absolute threshold
+        significance_threshold = int(total_responses * (significance_percentage / 100))
+
+        # Filter themes that meet the significance threshold
+        significant_themes = [
+            theme_node
+            for theme_node in self.themes.values()
+            if theme_node.source_topic_count >= significance_threshold
+        ]
+        # Convert significant themes to DataFrame, excluding root node
+        theme_nodes_dicts = [
+            node.model_dump() for node in significant_themes if node.topic_id != "0"
+        ]
+        return pd.DataFrame(theme_nodes_dicts)

{themefinder-0.6.2.dist-info → themefinder-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: themefinder
-Version: 0.6.2
+Version: 0.7.0
 Summary: A topic modelling Python package designed for analysing one-to-many question-answer data eg free-text survey responses.
 License: MIT
 Author: i.AI
@@ -49,9 +49,9 @@ ThemeFinder takes as input a [pandas DataFrame](https://pandas.pydata.org/docs/r
 - `response_id`: A unique identifier for each response
 - `response`: The free text survey response
 
-ThemeFinder is compatible with any instantiated [LangChain LLM runnable](https://python.langchain.com/v0.1/docs/integrations/llms/), but you will need to use JSON structured output.
+ThemeFinder now supports a range of language models through structured outputs.
 
-The function `find_themes` identifies common themes in response and labels them, it also outputs results from intermediate steps in the theme finding pipeline.
+The function `find_themes` identifies common themes in responses and labels them, it also outputs results from intermediate steps in the theme finding pipeline.
 
 For this example, import the following Python packages into your virtual environment: `asyncio`, `pandas`, `lanchain`. And import `themefinder` as described above.
 
@@ -81,7 +81,6 @@ load_dotenv()
 llm = AzureChatOpenAI(
     model="gpt-4o",
     temperature=0,
-    model_kwargs={"response_format": {"type": "json_object"}},
 )
 
 # Set up your data
@@ -97,18 +96,15 @@ question = "What do you think of ThemeFinder?"
 # Make the system prompt specific to your use case 
 system_prompt = "You are an AI evaluation tool analyzing survey responses about a Python package."
 
-# Run the function to find themes
-# We use asyncio to query LLM endpoints asynchronously, so we need to await our function
+# Run the function to find themes, we use asyncio to query LLM endpoints asynchronously, so we need to await our function
 async def main():
     result = await find_themes(responses_df, llm, question, system_prompt=system_prompt)
     print(result)
 
 if __name__ == "__main__":
     asyncio.run(main())
-
 ```
 
-
 ## ThemeFinder pipeline
 
 ThemeFinder's pipeline consists of five distinct stages, each utilizing a specialized LLM prompt:
@@ -145,6 +141,25 @@ The file `src/themefinder.core.py` contains the function `find_themes` which run
 **For more detail - see the docs: [https://i-dot-ai.github.io/themefinder/](https://i-dot-ai.github.io/themefinder/).**
 
 
+## Model Compatibility
+
+ThemeFinder's structured output approach makes it compatible with a wide range of language models from various providers. This list is non-exhaustive, and other models may also work effectively:
+
+### OpenAI Models
+- GPT-4, GPT-4o, GPT-4.1
+- All Azure OpenAI deployments
+
+### Google Models
+- Gemini series (1.5 Pro, 2.0 Pro, etc.)
+
+### Anthropic Models
+- Claude series (Claude 3 Opus, Sonnet, Haiku, etc.)
+
+### Open Source Models
+- Llama 2, Llama 3
+- Mistral models (e.g., Mistral 7B, Mixtral)
+
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
@@ -154,5 +169,5 @@ The documentation is [© Crown copyright](https://www.nationalarchives.gov.uk/in
 
 ## Feedback
 
-If you have feedback on this package, please fill in our [feedback form](https://forms.gle/85xUSMvxGzSSKQ499) or contact us with questions or feedback at packages@cabinetoffice.gov.uk.
+Contact us with questions or feedback at packages@cabinetoffice.gov.uk.
 

themefinder-0.7.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+themefinder/__init__.py,sha256=k3D3TpAvRdcXXZbHc_Lb7DsB53JwoGA0S4Ap5iX7PEw,477
+themefinder/core.py,sha256=mqToJ-ggx8JyholNMUwFDcAT35dWX8Hnt3BJzdaNgS0,26219
+themefinder/llm_batch_processor.py,sha256=Z9jm9Kr-6GD8g8kLkgdW97onjUbLLQ2M1YKwok39Q6Y,17652
+themefinder/models.py,sha256=JopmD4F23Mteh60m6WDpsuTs58dRc0tUbVX-d-L8Gv8,14680
+themefinder/prompts/agentic_theme_clustering.txt,sha256=6bHLpgZUQEaZXpLUB7EcMEbtXGqQ_1yniqZ6ZBJHFn0,1917
+themefinder/prompts/consultation_system_prompt.txt,sha256=_A07oY_an4hnRx-9pQ0y-TLXJz0dd8vDI-MZne7Mdb4,89
+themefinder/prompts/detail_detection.txt,sha256=6Vr_oN7rF5BCFipnCIHTSF8MmjerGyCixRWRT3vni1U,941
+themefinder/prompts/sentiment_analysis.txt,sha256=vYCDhtEsG5I9xixwVhZbvKPJGU1Gqpw4-xAqGz72xhU,1671
+themefinder/prompts/theme_condensation.txt,sha256=pHWuCtfU58gdtP2BfGZWOTvcb0MnTpb9OhOCGtkJv8U,1672
+themefinder/prompts/theme_generation.txt,sha256=QRKW7DtcMSb2olT6j5jmdEPcXPMeZgogM-NYddEIKRk,1871
+themefinder/prompts/theme_mapping.txt,sha256=HtGuStm-622TIEaqdb9LTaBs9xE-n9lvmcGQTG2_JOQ,2042
+themefinder/prompts/theme_refinement.txt,sha256=evWMCIEdeZCJ8zn4SBNgP6bmfAb0vzKiR5C5wfAjkUk,2649
+themefinder/prompts/theme_target_alignment.txt,sha256=g7AVZLiP_xIH010X5SIZyG3q7gA6OBAplPv3xvmstOY,855
+themefinder/theme_clustering_agent.py,sha256=Ie-5MFvIo7ukeeDXNpLawJXqLqBb6kvUGgSH6uTGL20,12826
+themefinder/themefinder_logging.py,sha256=n5SUQovEZLC4skEbxicjz_fOGF9mOk3S-Wpj5uXsaL8,314
+themefinder-0.7.0.dist-info/LICENCE,sha256=C9ULIN0ctF60ZxUWH_hw1H434bDLg49Z-Qzn6BUHgqs,1060
+themefinder-0.7.0.dist-info/METADATA,sha256=-PRjz0RTxp-yJsuavj8tw5NwtC1amsw12JyKNOitxZw,6737
+themefinder-0.7.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+themefinder-0.7.0.dist-info/RECORD,,

{themefinder-0.6.2.dist-info → themefinder-0.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

themefinder-0.6.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-themefinder/__init__.py,sha256=wSpW2fEnC4gTzbeNC78nSD3DpJq43-h_H-LK_cqt1cw,327
-themefinder/core.py,sha256=u1DY9gbzn-tFhQS3hrXQ8_1mIbR-iBWYVAdKeAX1BdE,18304
-themefinder/llm_batch_processor.py,sha256=OrFEl1nSi5ninbSZSiE1HFMcYZiQ-NzuYPj_iDcPPoE,19988
-themefinder/models.py,sha256=Y5-okndYwtBO09n_qUlYNVmHRVNEnJviArQZukm8Ox8,4251
-themefinder/prompts/consultation_system_prompt.txt,sha256=_A07oY_an4hnRx-9pQ0y-TLXJz0dd8vDI-MZne7Mdb4,89
-themefinder/prompts/sentiment_analysis.txt,sha256=9-LkdR95JTHXRKUXknAgNf86uVdv6jSaXMf-OtFL9_0,1948
-themefinder/prompts/theme_condensation.txt,sha256=DB4pqUmMpo0OG4AZWGTj0FfLFfjbX6wOMUr44HBxZ1o,2433
-themefinder/prompts/theme_generation.txt,sha256=JMXuNojxdSAcxPRU1Jg12Xunv_dX4hNvXYU2pXMWTAw,2500
-themefinder/prompts/theme_mapping.txt,sha256=YcRGMkuTyTPzPQPtsDY31DUwX60c8AdmdHKw0XeUejQ,2258
-themefinder/prompts/theme_refinement.txt,sha256=hBXwZnNZmhmoEFXpY5OJinp-7xxdoDRf_5LmgrilYgc,2713
-themefinder/prompts/theme_target_alignment.txt,sha256=-_ghr4--KAN6Tz8ExO9s2IXvI6pjWaEA_nG5L83GV5I,1035
-themefinder/themefinder_logging.py,sha256=n5SUQovEZLC4skEbxicjz_fOGF9mOk3S-Wpj5uXsaL8,314
-themefinder-0.6.2.dist-info/LICENCE,sha256=C9ULIN0ctF60ZxUWH_hw1H434bDLg49Z-Qzn6BUHgqs,1060
-themefinder-0.6.2.dist-info/METADATA,sha256=gI9Hp754EjopJQWw0QZIPb9dex8TalPMGnorUEOJlp0,6498
-themefinder-0.6.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-themefinder-0.6.2.dist-info/RECORD,,