quantalogic 0.35.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

quantalogic/tools/utils/create_sample_database.py

@@ -8,16 +8,18 @@ from sqlalchemy.orm import declarative_base, relationship, sessionmaker
 Base = declarative_base()
 fake = Faker()
 
+
 def create_sample_database(db_path: str) -> None:
     """
     Creates a sample SQLite database with 5 tables and 10 rows each.
-    
+
     Args:
         db_path: Path to the SQLite database file (e.g., 'sample.db')
     """
+
     # Define database schema
     class Customer(Base):
-        __tablename__ = 'customers'
+        __tablename__ = "customers"
         id = Column(Integer, primary_key=True)
         name = Column(String)
         email = Column(String)
@@ -25,38 +27,38 @@ def create_sample_database(db_path: str) -> None:
         orders = relationship("Order", back_populates="customer")
 
     class Address(Base):
-        __tablename__ = 'addresses'
+        __tablename__ = "addresses"
         id = Column(Integer, primary_key=True)
         street = Column(String)
         city = Column(String)
-        customer_id = Column(Integer, ForeignKey('customers.id'))
+        customer_id = Column(Integer, ForeignKey("customers.id"))
         customer = relationship("Customer", back_populates="addresses")
 
     class Product(Base):
-        __tablename__ = 'products'
+        __tablename__ = "products"
         id = Column(Integer, primary_key=True)
         name = Column(String)
         price = Column(Float)
 
     class Order(Base):
-        __tablename__ = 'orders'
+        __tablename__ = "orders"
         id = Column(Integer, primary_key=True)
         order_date = Column(Date)
-        customer_id = Column(Integer, ForeignKey('customers.id'))
+        customer_id = Column(Integer, ForeignKey("customers.id"))
         customer = relationship("Customer", back_populates="orders")
         items = relationship("OrderItem", back_populates="order")
 
     class OrderItem(Base):
-        __tablename__ = 'order_items'
+        __tablename__ = "order_items"
         id = Column(Integer, primary_key=True)
         quantity = Column(Integer)
-        order_id = Column(Integer, ForeignKey('orders.id'))
-        product_id = Column(Integer, ForeignKey('products.id'))
+        order_id = Column(Integer, ForeignKey("orders.id"))
+        product_id = Column(Integer, ForeignKey("products.id"))
         order = relationship("Order", back_populates="items")
         product = relationship("Product")
 
     # Create database and tables
-    engine = create_engine(f'sqlite:///{db_path}')
+    engine = create_engine(f"sqlite:///{db_path}")
     Base.metadata.create_all(engine)
     Session = sessionmaker(bind=engine)  # noqa: N806
     session = Session()
@@ -66,59 +68,43 @@ def create_sample_database(db_path: str) -> None:
         # Create 10 customers
         customers = []
         for _ in range(10):
-            customer = Customer(
-                name=fake.name(),
-                email=fake.email()
-            )
+            customer = Customer(name=fake.name(), email=fake.email())
             customers.append(customer)
             session.add(customer)
-        
+
         session.commit()
 
         # Create 10 addresses (1 per customer)
         for customer in customers:
-            address = Address(
-                street=fake.street_address(),
-                city=fake.city(),
-                customer=customer
-            )
+            address = Address(street=fake.street_address(), city=fake.city(), customer=customer)
             session.add(address)
-        
+
         # Create 10 products
         products = []
         for _ in range(10):
-            product = Product(
-                name=fake.word().capitalize(),
-                price=round(random.uniform(10, 1000), 2)
-            )
+            product = Product(name=fake.word().capitalize(), price=round(random.uniform(10, 1000), 2))
             products.append(product)
             session.add(product)
-        
+
         # Create 10 orders (1 per customer)
         orders = []
         start_date = datetime.now() - timedelta(days=365)
         for customer in customers:
-            order = Order(
-                order_date=fake.date_between(start_date=start_date),
-                customer=customer
-            )
+            order = Order(order_date=fake.date_between(start_date=start_date), customer=customer)
             orders.append(order)
             session.add(order)
-        
+
         # Create 10 order items (1 per order)
         for order in orders:
-            order_item = OrderItem(
-                quantity=random.randint(1, 5),
-                order=order,
-                product=random.choice(products)
-            )
+            order_item = OrderItem(quantity=random.randint(1, 5), order=order, product=random.choice(products))
             session.add(order_item)
 
         session.commit()
     finally:
         session.close()
 
+
 # Example usage
 if __name__ == "__main__":
     create_sample_database("sample.db")
-    print("Sample database created successfully!")
+    print("Sample database created successfully!")

quantalogic/tools/utils/generate_database_report.py

@@ -9,24 +9,20 @@ from sqlalchemy.engine import Inspector
 def generate_database_report(connection_string: str) -> str:
     """
     Generates a comprehensive Markdown database documentation report with ER diagram.
-    
+
     Args:
         connection_string: SQLAlchemy-compatible database connection string
-        
+
     Returns:
         Markdown-formatted report as a string
     """
     # Setup database connection and inspection
     engine = create_engine(connection_string)
     inspector = inspect(engine)
-    
+
     # Collect database metadata
-    db_metadata = {
-        'name': engine.url.database,
-        'dialect': engine.dialect.name,
-        'tables': inspector.get_table_names()
-    }
-    
+    db_metadata = {"name": engine.url.database, "dialect": engine.dialect.name, "tables": inspector.get_table_names()}
+
     # Initialize data structures
     graph = nx.DiGraph()
     table_metadata: Dict[str, dict] = {}
@@ -35,61 +31,55 @@ def generate_database_report(connection_string: str) -> str:
     sample_data: Dict[str, list] = {}
 
     # Collect schema metadata and relationships
-    for table in db_metadata['tables']:
+    for table in db_metadata["tables"]:
         columns = inspector.get_columns(table)
-        pk = inspector.get_pk_constraint(table).get('constrained_columns', [])
+        pk = inspector.get_pk_constraint(table).get("constrained_columns", [])
         indexes = inspector.get_indexes(table)
         fks = inspector.get_foreign_keys(table)
-        
+
         # Process foreign keys
         for fk in fks:
             process_foreign_key(table, fk, inspector, graph, fk_relationships)
-        
-        table_metadata[table] = {
-            'columns': columns,
-            'primary_keys': pk,
-            'indexes': indexes,
-            'foreign_keys': fks
-        }
+
+        table_metadata[table] = {"columns": columns, "primary_keys": pk, "indexes": indexes, "foreign_keys": fks}
 
     # Process tables in dependency order
-    sorted_tables = get_sorted_tables(graph, db_metadata['tables'])
-    
+    sorted_tables = get_sorted_tables(graph, db_metadata["tables"])
+
     # Collect sample data with parent-child relationships
     collect_sample_data(engine, sorted_tables, table_metadata, sample_data, sampled_ids)
-    
+
     # Generate Markdown report
-    return generate_markdown_report(db_metadata, sorted_tables, table_metadata, 
-                                  fk_relationships, sample_data)
+    return generate_markdown_report(db_metadata, sorted_tables, table_metadata, fk_relationships, sample_data)
 
 
 def process_foreign_key(
-    table: str,
-    fk: dict,
-    inspector: Inspector,
-    graph: nx.DiGraph,
-    fk_relationships: List[dict]
+    table: str, fk: dict, inspector: Inspector, graph: nx.DiGraph, fk_relationships: List[dict]
 ) -> None:
     """Process and record foreign key relationships with cardinality information."""
-    src_col = fk['constrained_columns'][0]
-    tgt_table = fk['referred_table']
-    tgt_col = fk['referred_columns'][0]
-    
+    src_col = fk["constrained_columns"][0]
+    tgt_table = fk["referred_table"]
+    tgt_col = fk["referred_columns"][0]
+
     # Check uniqueness and nullability in source column
     src_columns = inspector.get_columns(table)
-    src_col_meta = next(c for c in src_columns if c['name'] == src_col)
-    is_unique = src_col_meta.get('unique', False) or src_col in inspector.get_pk_constraint(table).get('constrained_columns', [])
-    is_nullable = src_col_meta['nullable']
-
-    fk_relationships.append({
-        'source_table': table,
-        'source_column': src_col,
-        'target_table': tgt_table,
-        'target_column': tgt_col,
-        'constraint_name': fk['name'],
-        'is_unique': is_unique,
-        'is_nullable': is_nullable
-    })
+    src_col_meta = next(c for c in src_columns if c["name"] == src_col)
+    is_unique = src_col_meta.get("unique", False) or src_col in inspector.get_pk_constraint(table).get(
+        "constrained_columns", []
+    )
+    is_nullable = src_col_meta["nullable"]
+
+    fk_relationships.append(
+        {
+            "source_table": table,
+            "source_column": src_col,
+            "target_table": tgt_table,
+            "target_column": tgt_col,
+            "constraint_name": fk["name"],
+            "is_unique": is_unique,
+            "is_nullable": is_nullable,
+        }
+    )
     graph.add_edge(table, tgt_table)
 
 
@@ -106,7 +96,7 @@ def collect_sample_data(
     tables: List[str],
     table_metadata: Dict[str, dict],
     sample_data: Dict[str, list],
-    sampled_ids: Dict[str, list]
+    sampled_ids: Dict[str, list],
 ) -> None:
     """Collect sample data while maintaining referential integrity."""
     for table in tables:
@@ -115,10 +105,10 @@ def collect_sample_data(
             result = conn.execute(text(f"SELECT * FROM {table} LIMIT 5"))
             samples = [dict(row._mapping) for row in result]
             sample_data[table] = samples
-            
+
             # Store IDs for child sampling
-            if samples and table_metadata[table]['primary_keys']:
-                pk_col = table_metadata[table]['primary_keys'][0]
+            if samples and table_metadata[table]["primary_keys"]:
+                pk_col = table_metadata[table]["primary_keys"][0]
                 sampled_ids[table] = [row[pk_col] for row in samples]
 
 
@@ -127,24 +117,24 @@ def generate_markdown_report(
     tables: List[str],
     table_metadata: Dict[str, dict],
     fk_relationships: List[dict],
-    sample_data: Dict[str, list]
+    sample_data: Dict[str, list],
 ) -> str:
     """Generate the complete Markdown report."""
     md = []
-    
+
     # Database Summary
     md.append("# Database Documentation Report\n")
     md.append(f"**Database Type**: {db_metadata['dialect'].capitalize()}\n")
     md.append(f"**Database Name**: {db_metadata['name']}\n")
     md.append(f"**Total Tables**: {len(db_metadata['tables'])}\n")
     md.append(f"**Generated At**: {datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S UTC')}\n\n")
-    
+
     # ERD Section
     md.append("## Entity Relationship Diagram\n")
     md.append("```mermaid\nerDiagram\n")
     generate_erd_section(md, tables, table_metadata, fk_relationships)
     md.append("```\n\n")
-    
+
     # Schema Details
     md.append("## Schema Details\n")
     for table in tables:
@@ -152,48 +142,50 @@ def generate_markdown_report(
         md.append(f"### {table}\n")
         generate_columns_section(md, meta)
         generate_indexes_section(md, meta)
-    
+
     # Relationships
     generate_relationships_section(md, fk_relationships)
-    
+
     # Cardinality Report
     generate_cardinality_section(md, fk_relationships)
-    
+
     # Data Samples
     md.append("## Data Samples\n")
     for table in tables:
         samples = sample_data[table]
         md.append(f"### {table}\n")
         generate_sample_table(md, samples)
-    
-    return '\n'.join(md)
+
+    return "\n".join(md)
 
 
-def generate_erd_section(md: List[str], tables: List[str], table_metadata: Dict[str, dict], fk_relationships: List[dict]) -> None:
+def generate_erd_section(
+    md: List[str], tables: List[str], table_metadata: Dict[str, dict], fk_relationships: List[dict]
+) -> None:
     """Generate Mermaid ER diagram section."""
     # Define tables with their columns
     for table in tables:
         table_upper = table.upper()
         md.append(f"    {table_upper} {{\n")
-        for col in table_metadata[table]['columns']:
-            col_type = str(col['type']).split('(')[0].upper()  # Simplify type names
+        for col in table_metadata[table]["columns"]:
+            col_type = str(col["type"]).split("(")[0].upper()  # Simplify type names
             annotations = []
-            if col['name'] in table_metadata[table]['primary_keys']:
+            if col["name"] in table_metadata[table]["primary_keys"]:
                 annotations.append("PK")
             # Check if column is a foreign key
             for fk in fk_relationships:
-                if fk['source_table'] == table and fk['source_column'] == col['name']:
+                if fk["source_table"] == table and fk["source_column"] == col["name"]:
                     annotations.append("FK")
                     break
             annotation_str = " ".join(annotations)
             md.append(f"        {col_type} {col['name']} {annotation_str}\n")
         md.append("    }\n")
-    
+
     # Define relationships with cardinality
     for fk in fk_relationships:
-        target_table = fk['target_table'].upper()
-        source_table = fk['source_table'].upper()
-        source_cardinality = get_source_cardinality(fk['is_unique'], fk['is_nullable'])
+        target_table = fk["target_table"].upper()
+        source_table = fk["source_table"].upper()
+        source_cardinality = get_source_cardinality(fk["is_unique"], fk["is_nullable"])
         md.append(f"    {target_table} ||--{source_cardinality} {source_table} : \"{fk['constraint_name']}\"\n")
 
 
@@ -220,17 +212,17 @@ def generate_cardinality_section(md: List[str], fk_relationships: List[dict]) ->
     """Generate cardinality report section."""
     cardinalities = {}
     for fk in fk_relationships:
-        key = (fk['target_table'], fk['source_table'])
+        key = (fk["target_table"], fk["source_table"])
         if key in cardinalities:
             continue
-            
-        if fk['is_unique']:
+
+        if fk["is_unique"]:
             cardinality = "(1) → (1)"
         else:
             cardinality = "(1) → (N)"
-            
+
         cardinalities[key] = f"{fk['target_table']} {cardinality} {fk['source_table']}"
-    
+
     if cardinalities:
         md.append("## Cardinality Report\n")
         for entry in cardinalities.values():
@@ -243,18 +235,18 @@ def generate_columns_section(md: List[str], meta: dict) -> None:
     md.append("#### Columns\n")
     md.append("| Column Name | Data Type | Nullable? | Primary Key? |\n")
     md.append("|-------------|-----------|-----------|--------------|\n")
-    for col in meta['columns']:
-        pk = "Yes" if col['name'] in meta['primary_keys'] else "No"
+    for col in meta["columns"]:
+        pk = "Yes" if col["name"] in meta["primary_keys"] else "No"
         md.append(f"| `{col['name']}` | {col['type']} | {'Yes' if col['nullable'] else 'No'} | {pk} |\n")
     md.append("\n")
 
 
 def generate_indexes_section(md: List[str], meta: dict) -> None:
     """Generate indexes section."""
-    if meta['indexes']:
+    if meta["indexes"]:
         md.append("#### Indexes\n")
-        for idx in meta['indexes']:
-            columns = ", ".join(idx['column_names'])
+        for idx in meta["indexes"]:
+            columns = ", ".join(idx["column_names"])
             md.append(f"- `{idx['name']}` ({idx['type'] or 'INDEX'}) → {columns}\n")
         md.append("\n")
 
@@ -264,11 +256,11 @@ def generate_sample_table(md: List[str], samples: list) -> None:
     if not samples:
         md.append("No records found.\n\n")
         return
-        
+
     headers = samples[0].keys()
     md.append("| " + " | ".join(headers) + " |\n")
     md.append("|" + "|".join(["---"] * len(headers)) + "|\n")
-    
+
     for row in samples:
         values = []
         for val in row.values():
@@ -282,8 +274,8 @@ def generate_sample_table(md: List[str], samples: list) -> None:
 
 if __name__ == "__main__":
     from quantalogic.tools.utils.create_sample_database import create_sample_database
-    
+
     # Create and document sample database
     create_sample_database("sample.db")
     report = generate_database_report("sqlite:///sample.db")
-    print(report)
+    print(report)

quantalogic/tools/wikipedia_search_tool.py

@@ -64,12 +64,12 @@ class WikipediaSearchTool(Tool):
 
     def execute(self, query: str, page: Union[str, int] = 1, num_results: Union[str, int] = 10) -> str:
         """Execute a search query using Wikipedia API and return results.
-        
+
         Args:
             query: The search query to execute
             page: The page number to retrieve (1-based)
             num_results: Number of results to retrieve per page (1-50)
-            
+
         Returns:
             Formatted search results as a string with the following format:
             ==== Page X of results ====
@@ -80,7 +80,7 @@ class WikipediaSearchTool(Tool):
                URL
                Description
             ==== End of page X ====
-            
+
         Raises:
             ValueError: If any parameter is invalid
             RuntimeError: If API request fails
@@ -96,10 +96,10 @@ class WikipediaSearchTool(Tool):
 
         if page < 1:
             raise ValueError("Page number must be positive")
-            
+
         if num_results < 1 or num_results > 50:
             raise ValueError("Number of results must be between 1 and 50")
-            
+
         try:
             # Wikipedia API endpoint
             url = "https://en.wikipedia.org/w/api.php"
@@ -109,33 +109,33 @@ class WikipediaSearchTool(Tool):
                 "list": "search",
                 "srsearch": query,
                 "srlimit": num_results,
-                "sroffset": (page - 1) * num_results
+                "sroffset": (page - 1) * num_results,
             }
-            
+
             response = requests.get(url, params=params)
             response.raise_for_status()
             data = response.json()
-            
+
             output = []
             if "query" in data and "search" in data["query"]:
                 for idx, result in enumerate(data["query"]["search"], 1):
                     title = result.get("title", "No title")
                     snippet = result.get("snippet", "No description")
                     url = f"https://en.wikipedia.org/wiki/{title.replace(' ', '_')}"
-                    
+
                     output.append(f"{idx}. {title}")
                     output.append(f"   {url}")
                     output.append(f"   {snippet}")
                     output.append("")
-            
+
             if not output:
                 return "No results found"
-                
+
             output.insert(0, f"==== Page {page} of results ====")
             output.append(f"==== End of page {page} ====")
-            
+
             return "\n".join(output)
-            
+
         except Exception as e:
             raise RuntimeError(f"Search failed: {str(e)}")
 
@@ -144,23 +144,19 @@ def main():
     """Demonstrate WikipediaSearchTool functionality."""
     try:
         tool = WikipediaSearchTool()
-        
+
         # Test basic search functionality
         print("Testing WikipediaSearchTool with sample query...")
-        results = tool.execute(
-            query="Python programming",
-            page=1,
-            num_results=3
-        )
+        results = tool.execute(query="Python programming", page=1, num_results=3)
         print(results)
-        
+
         # Test error handling
         print("\nTesting error handling with invalid query...")
         try:
             tool.execute(query="")
         except ValueError as e:
             print(f"Caught expected ValueError: {e}")
-            
+
     except Exception as e:
         print(f"Error in main: {e}")
 

quantalogic/utils/ask_user_validation.py

@@ -9,4 +9,4 @@ def console_ask_for_user_validation(question: str = "Do you want to continue?")
     """
     from rich.prompt import Confirm
 
-    return Confirm.ask(question, default=True)
+    return Confirm.ask(question, default=True)

quantalogic/utils/async_utils.py

@@ -0,0 +1,35 @@
+"""Utility functions for working with asynchronous code."""
+
+import asyncio
+from functools import wraps
+from typing import Any, Callable, Coroutine, TypeVar
+
+T = TypeVar("T")
+
+
+def run_async(func: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
+    """
+    Decorator that runs an async function in a synchronous context.
+
+    This allows using async functions in sync code by automatically handling
+    the event loop management.
+
+    Args:
+        func: The async function to be wrapped
+
+    Returns:
+        A synchronous function that calls the async function
+    """
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> T:
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            # Create a new event loop if one doesn't exist
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        return loop.run_until_complete(func(*args, **kwargs))
+
+    return wrapper

quantalogic/utils/check_version.py

@@ -1,13 +1,12 @@
-
 import requests
 from packaging import version
 
 from quantalogic.version import get_version
 
 
-def check_if_is_latest_version() -> (bool,str|None):
+def check_if_is_latest_version() -> (bool, str | None):
     """Check if the current version is the latest version on PyPI.
-    
+
     Returns:
         bool: True if the current version is the latest, False otherwise
     """
@@ -32,7 +31,6 @@ def main():
     else:
         print("❌ Could not check version")
 
+
 if __name__ == "__main__":
     main()
-
-

quantalogic/utils/get_all_models.py

@@ -14,7 +14,8 @@ def get_all_models() -> list[str]:
     quantalogic_models = set(model_info.keys())
     return list(litellm_models.union(quantalogic_models))
 
+
 # Example usage
 if __name__ == "__main__":
     models = get_all_models()
-    print("Supported models:", models)
+    print("Supported models:", models)