ai-data-science-team 0.0.0.9005__py3-none-any.whl → 0.0.0.9007__py3-none-any.whl

ai_data_science_team/templates/agent_templates.py

@@ -3,6 +3,7 @@ from langgraph.graph import StateGraph, END
 from langgraph.types import interrupt, Command
 
 import pandas as pd
+import sqlalchemy as sql
 
 from typing import Any, Callable, Dict, Type, Optional
 
@@ -22,7 +23,9 @@ def create_coding_agent_graph(
     retry_count_key: str = "retry_count",
     human_in_the_loop: bool = False,
     human_review_node_name: str = "human_review",
-    checkpointer: Optional[Callable] = None
+    checkpointer: Optional[Callable] = None,
+    bypass_recommended_steps: bool = False,
+    bypass_explain_code: bool = False,
 ):
     """
     Creates a generic agent graph using the provided node functions and node names.
@@ -63,7 +66,11 @@ def create_coding_agent_graph(
         The node name for human review if human_in_the_loop is True.
     checkpointer : callable, optional
         A checkpointer callable if desired.
-        
+    bypass_recommended_steps : bool, optional
+        Whether to skip the recommended steps node.
+    bypass_explain_code : bool, optional
+        Whether to skip the final explain code node.
+
     Returns
     -------
     app : langchain.graphs.StateGraph
@@ -72,50 +79,76 @@ def create_coding_agent_graph(
 
     workflow = StateGraph(GraphState)
     
-    # Add the recommended steps node
-    workflow.add_node(recommended_steps_node_name, node_functions[recommended_steps_node_name])
+    # Conditionally add the recommended-steps node
+    if not bypass_recommended_steps:
+        workflow.add_node(recommended_steps_node_name, node_functions[recommended_steps_node_name])
     
-    # Optionally add the human review node
-    if human_in_the_loop:
-        workflow.add_node(human_review_node_name, node_functions[human_review_node_name])
-        
-    # Add main nodes
+    # Always add create, execute, and fix nodes
     workflow.add_node(create_code_node_name, node_functions[create_code_node_name])
     workflow.add_node(execute_code_node_name, node_functions[execute_code_node_name])
     workflow.add_node(fix_code_node_name, node_functions[fix_code_node_name])
-    workflow.add_node(explain_code_node_name, node_functions[explain_code_node_name])
+    
+    # Conditionally add the explanation node
+    if not bypass_explain_code:
+        workflow.add_node(explain_code_node_name, node_functions[explain_code_node_name])
     
     # Set the entry point
-    workflow.set_entry_point(recommended_steps_node_name)
+    entry_point = create_code_node_name if bypass_recommended_steps else recommended_steps_node_name
+    workflow.set_entry_point(entry_point)
     
-    # Add edges depending on human_in_the_loop
-    if human_in_the_loop:
-        workflow.add_edge(recommended_steps_node_name, human_review_node_name)
-    else:
-        workflow.add_edge(recommended_steps_node_name, create_code_node_name)
+    # Add edges for recommended steps
+    if not bypass_recommended_steps:
+        if human_in_the_loop:
+            workflow.add_edge(recommended_steps_node_name, human_review_node_name)
+        else:
+            workflow.add_edge(recommended_steps_node_name, create_code_node_name)
+    elif human_in_the_loop:
+        # Skip recommended steps but still include human review
+        workflow.add_edge(create_code_node_name, human_review_node_name)
     
-    # Connect create_code_node to execution node
+    # Create -> Execute
     workflow.add_edge(create_code_node_name, execute_code_node_name)
     
-    # Add conditional edges for error handling
-    workflow.add_conditional_edges(
-        execute_code_node_name,
-        lambda state: "fix_code" if (
-            state.get(error_key) is not None and
-            state.get(retry_count_key) is not None and
-            state.get(max_retries_key) is not None and
-            state.get(retry_count_key) < state.get(max_retries_key)
-        ) else "explain_code",
-        {"fix_code": fix_code_node_name, "explain_code": explain_code_node_name},
-    )
-    
-    # From fix_code_node_name back to execution node
-    workflow.add_edge(fix_code_node_name, execute_code_node_name)
-    
-    # explain_code_node_name leads to end
-    workflow.add_edge(explain_code_node_name, END)
-    
-    # Compile workflow, optionally with checkpointer
+    # Define a helper to check if we have an error & can still retry
+    def error_and_can_retry(state):
+        return (
+            state.get(error_key) is not None
+            and state.get(retry_count_key) is not None
+            and state.get(max_retries_key) is not None
+            and state[retry_count_key] < state[max_retries_key]
+        )
+    
+    # ---- Split into two branches for bypass_explain_code ----
+    if not bypass_explain_code:
+        # If we are NOT bypassing explain, the next node is fix_code if error,
+        # else explain_code. Then we wire explain_code -> END afterward.
+        workflow.add_conditional_edges(
+            execute_code_node_name,
+            lambda s: "fix_code" if error_and_can_retry(s) else "explain_code",
+            {
+                "fix_code": fix_code_node_name,
+                "explain_code": explain_code_node_name,
+            },
+        )
+        # Fix code -> Execute again
+        workflow.add_edge(fix_code_node_name, execute_code_node_name)
+        # explain_code -> END
+        workflow.add_edge(explain_code_node_name, END)
+    else:
+        # If we ARE bypassing explain_code, the next node is fix_code if error,
+        # else straight to END.
+        workflow.add_conditional_edges(
+            execute_code_node_name,
+            lambda s: "fix_code" if error_and_can_retry(s) else "END",
+            {
+                "fix_code": fix_code_node_name,
+                "END": END,
+            },
+        )
+        # Fix code -> Execute again
+        workflow.add_edge(fix_code_node_name, execute_code_node_name)
+    
+    # Finally, compile
     if human_in_the_loop and checkpointer is not None:
         app = workflow.compile(checkpointer=checkpointer)
     else:
@@ -124,6 +157,7 @@ def create_coding_agent_graph(
     return app
 
 
+
 def node_func_human_review(
     state: Any, 
     prompt_text: str, 
@@ -256,6 +290,88 @@ def node_func_execute_agent_code_on_data(
         # if state.get("retry_count") == 0:
         #     10/0
         
+        # Apply post-processing if provided
+        if post_processing is not None:
+            result = post_processing(result)
+        else:
+            if isinstance(result, pd.DataFrame):
+                result = result.to_dict()   
+        
+    except Exception as e:
+        print(e)
+        agent_error = f"{error_message_prefix}{str(e)}"
+    
+    # Return results
+    output = {result_key: result, error_key: agent_error}
+    return output
+
+def node_func_execute_agent_from_sql_connection(
+    state: Any, 
+    connection: Any, 
+    code_snippet_key: str, 
+    result_key: str,
+    error_key: str,
+    agent_function_name: str,
+    post_processing: Optional[Callable[[Any], Any]] = None,
+    error_message_prefix: str = "An error occurred during agent execution: "
+) -> Dict[str, Any]:
+    """
+    Execute a generic agent code defined in a code snippet retrieved from the state on a SQLAlchemy connection object 
+    and return the result.
+    
+    Parameters
+    ----------
+    state : Any
+        A state object that supports `get(key: str)` method to retrieve values.
+    connection : str
+        The SQLAlchemy connection object to use for executing the agent function.
+    code_snippet_key : str
+        The key in the state used to retrieve the Python code snippet defining the agent function.
+    result_key : str
+        The key in the state used to store the result of the agent function.
+    error_key : str
+        The key in the state used to store the error message if any.
+    agent_function_name : str
+        The name of the function (e.g., 'sql_database_agent') expected to be defined in the code snippet.
+    post_processing : Callable[[Any], Any], optional
+        A function to postprocess the output of the agent function before returning it.
+    error_message_prefix : str, optional
+        A prefix or full message to use in the error output if an exception occurs.
+    
+    Returns
+    -------
+    Dict[str, Any]
+        A dictionary containing the result and/or error messages. Keys are arbitrary, 
+        but typically include something like "result" or "error".
+    """
+    
+    print("    * EXECUTING AGENT CODE ON SQL CONNECTION")
+    
+    # Retrieve SQLAlchemy connection and code snippet from the state
+    is_engine = isinstance(connection, sql.engine.base.Engine)
+    conn = connection.connect() if is_engine else connection
+    agent_code = state.get(code_snippet_key)
+    
+    # Ensure the connection object is provided
+    if connection is None:
+        raise ValueError(f"Connection object not found.")
+    
+    # Execute the code snippet to define the agent function
+    local_vars = {}
+    global_vars = {}
+    exec(agent_code, global_vars, local_vars)
+    
+    # Retrieve the agent function from the executed code
+    agent_function = local_vars.get(agent_function_name, None)
+    if agent_function is None or not callable(agent_function):
+        raise ValueError(f"Agent function '{agent_function_name}' not found or not callable in the provided code.")
+    
+    # Execute the agent function
+    agent_error = None
+    result = None
+    try:
+        result = agent_function(connection)
+        
         # Apply post-processing if provided
         if post_processing is not None:
             result = post_processing(result)
@@ -267,6 +383,7 @@ def node_func_execute_agent_code_on_data(
     output = {result_key: result, error_key: agent_error}
     return output
 
+
 def node_func_fix_agent_code(
     state: Any, 
     code_snippet_key: str, 
@@ -326,7 +443,7 @@ def node_func_fix_agent_code(
     response = (llm | PythonOutputParser()).invoke(prompt)
     
     response = relocate_imports_inside_function(response)
-    response = add_comments_to_top(response, agent_name="data_wrangler")
+    response = add_comments_to_top(response, agent_name=agent_name)
     
     # Log the response if requested
     if log:

ai_data_science_team/tools/logging.py

@@ -58,4 +58,4 @@ def log_ai_function(response: str, file_name: str, log: bool = True, log_path: s
         return (file_path, file_name)
     
     else:
-        return None
+        return (None, None)

ai_data_science_team/tools/metadata.py

@@ -0,0 +1,230 @@
+import io
+import pandas as pd
+import sqlalchemy as sql
+from typing import Union, List, Dict
+
+def get_dataframe_summary(
+    dataframes: Union[pd.DataFrame, List[pd.DataFrame], Dict[str, pd.DataFrame]],
+    n_sample: int = 30,
+    skip_stats: bool = False,
+) -> List[str]:
+    """
+    Generate a summary for one or more DataFrames. Accepts a single DataFrame, a list of DataFrames,
+    or a dictionary mapping names to DataFrames.
+
+    Parameters
+    ----------
+    dataframes : pandas.DataFrame or list of pandas.DataFrame or dict of (str -> pandas.DataFrame)
+        - Single DataFrame: produce a single summary (returned within a one-element list).
+        - List of DataFrames: produce a summary for each DataFrame, using index-based names.
+        - Dictionary of DataFrames: produce a summary for each DataFrame, using dictionary keys as names.
+    n_sample : int, default 30
+        Number of rows to display in the "Data (first 30 rows)" section.
+    skip_stats : bool, default False
+        If True, skip the descriptive statistics and DataFrame info sections.
+        
+    Example:
+    --------
+    ``` python
+    import pandas as pd
+    from sklearn.datasets import load_iris
+    data = load_iris(as_frame=True)
+    dataframes = {
+        "iris": data.frame,
+        "iris_target": data.target,
+    }
+    summaries = get_dataframe_summary(dataframes)
+    print(summaries[0])
+    ```
+
+    Returns
+    -------
+    list of str
+        A list of summaries, one for each provided DataFrame. Each summary includes:
+        - Shape of the DataFrame (rows, columns)
+        - Column data types
+        - Missing value percentage
+        - Unique value counts
+        - First 30 rows
+        - Descriptive statistics
+        - DataFrame info output
+    """
+
+    summaries = []
+
+    # --- Dictionary Case ---
+    if isinstance(dataframes, dict):
+        for dataset_name, df in dataframes.items():
+            summaries.append(_summarize_dataframe(df, dataset_name, n_sample, skip_stats))
+
+    # --- Single DataFrame Case ---
+    elif isinstance(dataframes, pd.DataFrame):
+        summaries.append(_summarize_dataframe(dataframes, "Single_Dataset", n_sample, skip_stats))
+
+    # --- List of DataFrames Case ---
+    elif isinstance(dataframes, list):
+        for idx, df in enumerate(dataframes):
+            dataset_name = f"Dataset_{idx}"
+            summaries.append(_summarize_dataframe(df, dataset_name, n_sample, skip_stats))
+
+    else:
+        raise TypeError(
+            "Input must be a single DataFrame, a list of DataFrames, or a dictionary of DataFrames."
+        )
+
+    return summaries
+
+
+def _summarize_dataframe(df: pd.DataFrame, dataset_name: str, n_sample=30, skip_stats=False) -> str:
+    """Generate a summary string for a single DataFrame."""
+    # 1. Convert dictionary-type cells to strings
+    #    This prevents unhashable dict errors during df.nunique().
+    df = df.apply(lambda col: col.map(lambda x: str(x) if isinstance(x, dict) else x))
+    
+    # 2. Capture df.info() output
+    buffer = io.StringIO()
+    df.info(buf=buffer)
+    info_text = buffer.getvalue()
+
+    # 3. Calculate missing value stats
+    missing_stats = (df.isna().sum() / len(df) * 100).sort_values(ascending=False)
+    missing_summary = "\n".join([f"{col}: {val:.2f}%" for col, val in missing_stats.items()])
+
+    # 4. Get column data types
+    column_types = "\n".join([f"{col}: {dtype}" for col, dtype in df.dtypes.items()])
+
+    # 5. Get unique value counts
+    unique_counts = df.nunique()  # Will no longer fail on unhashable dict
+    unique_counts_summary = "\n".join([f"{col}: {count}" for col, count in unique_counts.items()])
+
+    # 6. Generate the summary text
+    if not skip_stats:
+        summary_text = f"""
+        Dataset Name: {dataset_name}
+        ----------------------------
+        Shape: {df.shape[0]} rows x {df.shape[1]} columns
+
+        Column Data Types:
+        {column_types}
+
+        Missing Value Percentage:
+        {missing_summary}
+
+        Unique Value Counts:
+        {unique_counts_summary}
+
+        Data (first {n_sample} rows):
+        {df.head(n_sample).to_string()}
+
+        Data Description:
+        {df.describe().to_string()}
+
+        Data Info:
+        {info_text}
+        """
+    else:
+        summary_text = f"""
+        Dataset Name: {dataset_name}
+        ----------------------------
+        Shape: {df.shape[0]} rows x {df.shape[1]} columns
+
+        Column Data Types:
+        {column_types}
+
+        Data (first {n_sample} rows):
+        {df.head(n_sample).to_string()}
+        """
+        
+    return summary_text.strip()
+
+
+
+def get_database_metadata(connection: Union[sql.engine.base.Connection, sql.engine.base.Engine],
+                          n_samples: int = 10) -> str:
+    """
+    Collects metadata and sample data from a database, with safe identifier quoting and
+    basic dialect-aware row limiting. Prevents issues with spaces/reserved words in identifiers.
+    
+    Parameters
+    ----------
+    connection : Union[sql.engine.base.Connection, sql.engine.base.Engine]
+        An active SQLAlchemy connection or engine.
+    n_samples : int
+        Number of sample values to retrieve for each column.
+
+    Returns
+    -------
+    str
+        A formatted string with database metadata, including some sample data from each column.
+    """
+
+    # If a connection is passed, use it; if an engine is passed, connect to it
+    is_engine = isinstance(connection, sql.engine.base.Engine)
+    conn = connection.connect() if is_engine else connection
+
+    output = []
+    try:
+        # Grab the engine off the connection
+        sql_engine = conn.engine
+        dialect_name = sql_engine.dialect.name.lower()
+
+        output.append(f"Database Dialect: {sql_engine.dialect.name}")
+        output.append(f"Driver: {sql_engine.driver}")
+        output.append(f"Connection URL: {sql_engine.url}")
+
+        # Inspect the database
+        inspector = sql.inspect(sql_engine)
+        tables = inspector.get_table_names()
+        output.append(f"Tables: {tables}")
+        output.append(f"Schemas: {inspector.get_schema_names()}")
+
+        # Helper to build a dialect-specific limit clause
+        def build_query(col_name_quoted: str, table_name_quoted: str, n: int) -> str:
+            """
+            Returns a SQL query string to select N rows from the given column/table
+            across different dialects (SQLite, MySQL, Postgres, MSSQL, Oracle, etc.)
+            """
+            if "sqlite" in dialect_name or "mysql" in dialect_name or "postgres" in dialect_name:
+                # Common dialects supporting LIMIT
+                return f"SELECT {col_name_quoted} FROM {table_name_quoted} LIMIT {n}"
+            elif "mssql" in dialect_name:
+                # Microsoft SQL Server syntax
+                return f"SELECT TOP {n} {col_name_quoted} FROM {table_name_quoted}"
+            elif "oracle" in dialect_name:
+                # Oracle syntax
+                return f"SELECT {col_name_quoted} FROM {table_name_quoted} WHERE ROWNUM <= {n}"
+            else:
+                # Fallback
+                return f"SELECT {col_name_quoted} FROM {table_name_quoted} LIMIT {n}"
+
+        # Prepare for quoting
+        preparer = inspector.bind.dialect.identifier_preparer
+
+        # For each table, get columns and sample data
+        for table_name in tables:
+            output.append(f"\nTable: {table_name}")
+            # Properly quote the table name
+            table_name_quoted = preparer.quote_identifier(table_name)
+
+            for column in inspector.get_columns(table_name):
+                col_name = column["name"]
+                col_type = column["type"]
+                output.append(f"  Column: {col_name} Type: {col_type}")
+
+                # Properly quote the column name
+                col_name_quoted = preparer.quote_identifier(col_name)
+
+                # Build a dialect-aware query with safe quoting
+                query = build_query(col_name_quoted, table_name_quoted, n_samples)
+
+                # Read a few sample values
+                df = pd.read_sql(sql.text(query), conn)
+                first_values = df[col_name].tolist()
+                output.append(f"    First {n_samples} Values: {first_values}")
+
+    finally:
+        # Close connection if created inside the function
+        if is_engine:
+            conn.close()
+
+    return "\n".join(output)

ai_data_science_team/tools/regex.py

@@ -64,10 +64,16 @@ def add_comments_to_top(code_text, agent_name="data_wrangler"):
     header_comments = [
         "# Disclaimer: This function was generated by AI. Please review before using.",
         f"# Agent Name: {agent_name}",
-        f"# Time Created: {time_created}",
+        f"# Time Created: {time_created}\n",        
         ""
     ]
 
     # Join the header with newlines, then prepend to the existing code_text
     header_block = "\n".join(header_comments)
     return header_block + code_text
+
+def format_agent_name(agent_name: str) -> str:
+    
+    formatted_name = agent_name.strip().replace("_", " ").upper()
+    
+    return f"---{formatted_name}----"

{ai_data_science_team-0.0.0.9005.dist-info → ai_data_science_team-0.0.0.9007.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ai-data-science-team
-Version: 0.0.0.9005
+Version: 0.0.0.9007
 Summary: Build and run an AI-powered data science team.
 Home-page: https://github.com/business-science/ai-data-science-team
 Author: Matt Dancho
@@ -21,12 +21,22 @@ Requires-Dist: plotly
 Requires-Dist: streamlit
 Requires-Dist: scikit-learn
 Requires-Dist: xgboost
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Your AI Data Science Team (An Army Of Copilots)
 
 **An AI-powered data science team of copilots that uses agents to help you perform common data science tasks 10X faster**.
 
-Star ⭐ This GitHub (Takes 2 seconds and means a lot).
+**Star ⭐ This GitHub (Takes 2 seconds and means a lot).**
+
+*Beta - This Python library is under active development. There may be breaking changes that occur until release of 0.1.0.* 
 
 ---
 
@@ -39,6 +49,24 @@ The AI Data Science Team of Copilots includes Agents that specialize data cleani
 - Credit Card Risk
 - And more
 
+## Table of Contents
+
+- [Your AI Data Science Team (An Army Of Copilots)](#your-ai-data-science-team-an-army-of-copilots)
+  - [Table of Contents](#table-of-contents)
+  - [Companies That Want An AI Data Science Team Copilot](#companies-that-want-an-ai-data-science-team-copilot)
+  - [Free Generative AI For Data Scientists Workshop](#free-generative-ai-for-data-scientists-workshop)
+  - [Data Science Agents](#data-science-agents)
+    - [Coming Soon: Multi-Agents](#coming-soon-multi-agents)
+    - [Agents Available Now](#agents-available-now)
+    - [Agents Coming Soon](#agents-coming-soon)
+  - [Disclaimer](#disclaimer)
+  - [Installation](#installation)
+  - [Usage](#usage)
+    - [Example 1: Feature Engineering with the Feature Engineering Agent](#example-1-feature-engineering-with-the-feature-engineering-agent)
+    - [Example 2: Cleaning Data with the Data Cleaning Agent](#example-2-cleaning-data-with-the-data-cleaning-agent)
+  - [Contributing](#contributing)
+  - [License](#license)
+
 ## Companies That Want An AI Data Science Team Copilot
 
 If you are interested in having your own custom enteprise-grade AI Data Science Team Copilot, send inquiries here: [https://www.business-science.io/contact.html](https://www.business-science.io/contact.html)
@@ -53,11 +81,19 @@ This project is a work in progress. New data science agents will be released soo
 
 ![Data Science Team](/img/ai_data_science_team.jpg)
 
+### Coming Soon: Multi-Agents
+
+This is the internals of the Business Intelligence SQL Agent I'm working on:
+
+![Business Intelligence SQL Agent](/img/multi_agent_sql_data_visualization.jpg)
+
 ### Agents Available Now
 
 1. **Data Wrangling Agent:** Merges, Joins, Preps and Wrangles data into a format that is ready for data analysis.
-2. **Data Cleaning Agent:** Performs Data Preparation steps including handling missing values, outliers, and data type conversions.
-3. **Feature Engineering Agent:** Converts the prepared data into ML-ready data. Adds features to increase predictive accuracy of ML models.
+2. **Data Visualization Agent:** Creates visualizations to help you understand your data. Returns JSON serializable plotly visualizations.
+3. **Data Cleaning Agent:** Performs Data Preparation steps including handling missing values, outliers, and data type conversions.
+4. **Feature Engineering Agent:** Converts the prepared data into ML-ready data. Adds features to increase predictive accuracy of ML models.
+5. **SQL Database Agent:** Connects to SQL databases to pull data into the data science environment. Creates pipelines to automate data extraction. Performs Joins, Aggregations, and other SQL Query operations.
 
 ### Agents Coming Soon
 
@@ -78,23 +114,6 @@ This project is a work in progress. New data science agents will be released soo
 
 By using this software, you agree to use it solely for learning purposes.
 
-## Table of Contents
-
-- [Your AI Data Science Team (An Army Of Copilots)](#your-ai-data-science-team-an-army-of-copilots)
-  - [Companies That Want An AI Data Science Team Copilot](#companies-that-want-an-ai-data-science-team-copilot)
-  - [Free Generative AI For Data Scientists Workshop](#free-generative-ai-for-data-scientists-workshop)
-  - [Data Science Agents](#data-science-agents)
-    - [Agents Available Now](#agents-available-now)
-    - [Agents Coming Soon](#agents-coming-soon)
-  - [Disclaimer](#disclaimer)
-  - [Table of Contents](#table-of-contents)
-  - [Installation](#installation)
-  - [Usage](#usage)
-    - [Example 1: Feature Engineering with the Feature Engineering Agent](#example-1-feature-engineering-with-the-feature-engineering-agent)
-    - [Example 2: Cleaning Data with the Data Cleaning Agent](#example-2-cleaning-data-with-the-data-cleaning-agent)
-  - [Contributing](#contributing)
-  - [License](#license)
-
 ## Installation
 
 ``` bash
@@ -103,6 +122,8 @@ pip install git+https://github.com/business-science/ai-data-science-team.git --u
 
 ## Usage
 
+[See all examples here.](/examples)
+
 ### Example 1: Feature Engineering with the Feature Engineering Agent
 
 [See the full example here.](/examples/feature_engineering_agent.ipynb)

ai_data_science_team-0.0.0.9007.dist-info/RECORD

@@ -0,0 +1,21 @@
+ai_data_science_team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_data_science_team/_version.py,sha256=VJYpfOaKsXjGzPOsT6kYyVW6T9bFBqxt6Ph3qF8t-A8,26
+ai_data_science_team/orchestration.py,sha256=xiIFOsrLwPdkSmtme7wNCCGv8XopnMTNElNzlZokL-4,303
+ai_data_science_team/agents/__init__.py,sha256=rcF18rBsOuPJqJKvoffh6lwr4Nwm24MErM2u4H4Th9s,467
+ai_data_science_team/agents/data_cleaning_agent.py,sha256=gixYY4wGehKK_ROgU7CVOzijghmVQGD4hyK9uKhc8Hw,20890
+ai_data_science_team/agents/data_visualization_agent.py,sha256=wePFZbdB4kBah8m_iy6f4IDyjl6L6zBWzIgigJEXdk8,12933
+ai_data_science_team/agents/data_wrangling_agent.py,sha256=5w1kytoWLE4p3hj0YHVuXcgCd304eNQac-Zrrgmnr2s,16735
+ai_data_science_team/agents/feature_engineering_agent.py,sha256=UaaU3VkPhjOV0NbrYXedRb6eHOcOWWiGYhB_srrYWvg,17571
+ai_data_science_team/agents/sql_database_agent.py,sha256=mRbEAPHP6NlwQac2_VL9RuyIfCCtrmXTrzu5RLzOoeU,16031
+ai_data_science_team/templates/__init__.py,sha256=bNrKGmWXQG7GRczln_zVfUQLzxzp7hSwlLyNtLxleu4,278
+ai_data_science_team/templates/agent_templates.py,sha256=xohVgEfxPcVukPLpPfV7mZ0cpFgp-oJVLZRWCv2V-WU,19948
+ai_data_science_team/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_data_science_team/tools/logging.py,sha256=7wFOv6GGhXR_RPbh-8p0GyrS608XOnZtiaGK2IbDl_s,2081
+ai_data_science_team/tools/metadata.py,sha256=tbnca_tDp67oBA6qD29AKVooJG10VqGr4vwzj4rPUas,8348
+ai_data_science_team/tools/parsers.py,sha256=BAi-fJT7BBt9nRS3w5n9LDTsu7JAJsH8CAI9-Qf7jCs,2086
+ai_data_science_team/tools/regex.py,sha256=vkfdvi9pDe582p-fh_7cB07Wb0dOR2CsiVq-wUO3mas,2491
+ai_data_science_team-0.0.0.9007.dist-info/LICENSE,sha256=Xif0IRLdd2HGLATxV2EVp91aSY6KOuacRr_6BorKGzA,1084
+ai_data_science_team-0.0.0.9007.dist-info/METADATA,sha256=KcMFR2V9_wbepdKsrlFdfc7UB7t-Hf7i75x67LPXw3Q,6783
+ai_data_science_team-0.0.0.9007.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ai_data_science_team-0.0.0.9007.dist-info/top_level.txt,sha256=CnoMgOphCoAdGTLueWdCVByVyjwOubaGiTB1lchdy4M,21
+ai_data_science_team-0.0.0.9007.dist-info/RECORD,,

{ai_data_science_team-0.0.0.9005.dist-info → ai_data_science_team-0.0.0.9007.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any