zerottmm 0.1.0__tar.gz

zerottmm-0.1.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: zerottmm
+Version: 0.1.0
+Summary: Time‑to‑Mental‑Model: a local‑first code reading assistant (Phase A)
+Author-email: Gaurav Sood <contact@gsood.com>
+License-Expression: MIT
+Keywords: code-analysis,static-analysis,code-reading,python,ast
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: ui
+Requires-Dist: streamlit>=1.23; extra == "ui"
+Requires-Dist: openai>=1.0.0; extra == "ui"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: ai
+Requires-Dist: openai>=1.0.0; extra == "ai"
+Provides-Extra: all
+Requires-Dist: streamlit>=1.23; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: openai>=1.0.0; extra == "all"
+
+# ttmm: Time‑to‑Mental‑Model
+
+`ttmm` is a local‑first code reading assistant designed to reduce the time it takes to load a mental model of a codebase.  It provides static indexing, simple call graph navigation, hotspot detection and dynamic tracing.  You can use it either from the command line or through a Streamlit web UI.
+
+**New**: `ttmm` now supports remote repositories via Git URLs and GitIngest integration, making it easy to analyze any public Python repository without cloning manually.
+
+## Key features (Phase A)
+
+* **Index your repository** – builds a lightweight SQLite database of all Python functions/methods, their definitions, references and coarse call edges using only the standard library.
+* **Remote repository support** – analyze any GitHub, GitLab, or Bitbucket repository directly via URL or GitIngest links without manual cloning.
+* **Hotspot detection** – computes a hotspot score by combining cyclomatic complexity and recent git churn to help you prioritise where to read first.
+* **Static call graph navigation** – shows callers and callees for any symbol using conservative AST analysis.  Attribute calls that cannot be resolved are marked as `<unresolved>`.
+* **Keyword search** – a tiny TF‑IDF engine lets you ask a natural language question and returns a minimal reading set of relevant symbols.
+* **Dynamic tracing** – run a module, function or script with `sys.settrace` to capture the actual call sequence executed at runtime and persist it in the database.
+
+## Installation
+
+Requirements:
+
+* Python 3.8 or later (except 3.9.7 due to Streamlit compatibility)
+* A `git` executable in your `PATH` if you want churn‑based hotspot scores
+
+Install from PyPI:
+
+```bash
+pip install zerottmm
+```
+
+Or install in development mode from this repository:
+
+```bash
+pip install -e .
+```
+
+To enable optional extras:
+
+* `[ui]` – install `streamlit` and `openai` for the web UI with AI features
+* `[test]` – install `pytest` for running the test suite  
+* `[ai]` – install `openai` for AI-enhanced analysis
+
+For example:
+
+```bash
+pip install zerottmm[ui,test]
+```
+
+## Command line usage
+
+After installation a `zerottmm` command will be available:
+
+```bash
+zerottmm index PATH_OR_URL        # index a Python repository (local or remote)
+zerottmm hotspots PATH            # show the top hotspots (default 10)
+zerottmm callers PATH SYMBOL
+zerottmm callees PATH SYMBOL
+zerottmm trace PATH [--module pkg.mod:func | --script file.py] [-- args...]
+zerottmm answer PATH "your question"
+```
+
+* **PATH_OR_URL** – local repository path, Git URL, or GitIngest URL
+* **PATH** – local repository path that has been indexed previously
+* **SYMBOL** – a fully‑qualified name like `package.module:Class.method` or `package.module:function`.
+* **--module** – run a function or module entry point (e.g. `package.module:main`) and trace calls within the repository.
+* **--script** – run an arbitrary Python script in the repository and trace calls.
+
+Use `zerottmm --help` for full documentation.
+
+## Examples
+
+Here are some examples analyzing popular Python repositories:
+
+### Analyze the Python requests library
+```bash
+# Index directly from GitHub
+zerottmm index https://github.com/psf/requests.git
+
+# Find hotspots (complex functions with high churn)
+zerottmm hotspots /tmp/ttmm_repo_*/
+# Output: PreparedRequest.prepare_body, super_len, RequestEncodingMixin._encode_files
+
+# Ask natural language questions  
+zerottmm answer /tmp/ttmm_repo_*/ "how to make HTTP requests"
+# Output: HTTPAdapter.send, Session.request, HTTPAdapter.cert_verify
+```
+
+### Analyze a mathematical optimization library
+```bash  
+# Index a specialized repo via GitIngest URL
+zerottmm index "https://gitingest.com/?url=https://github.com/finite-sample/rank_preserving_calibration"
+
+# Find the main algorithmic components
+zerottmm answer /tmp/ttmm_repo_*/ "main calibration algorithm"
+# Output: calibrate_dykstra, calibrate_admm, _isotonic_regression
+
+# Explore function relationships
+zerottmm callers /tmp/ttmm_repo_*/ "calibrate_dykstra"  
+# Shows all the places this core algorithm is used
+```
+
+### Analyze FastAPI core (subpath example)
+```bash
+# Index just the FastAPI core module using GitIngest subpath
+zerottmm index "https://gitingest.com/?url=https://github.com/tiangolo/fastapi&subpath=fastapi"
+
+# Find entry points and main interfaces
+zerottmm answer /tmp/ttmm_repo_*/ "main application interface"
+```
+
+## Streamlit UI
+
+A simple web UI is provided under `app/app.py`.  To run it locally:
+
+```bash
+pip install -e .[ui]
+streamlit run app/app.py
+```
+
+The app allows you to index repositories (local or remote via GitIngest), explore hotspots, get AI-powered insights, and search interactively. Features include:
+
+* **Repository indexing** from local paths, Git URLs, or GitIngest links
+* **Automatic repository summary** with key metrics and analysis
+* **AI-enhanced analysis** with OpenAI integration (optional)
+* **Hotspot detection** and complexity analysis
+* **Natural language search** over code symbols
+
+The app is designed to run on [Streamlit Community Cloud](https://streamlit.io/cloud) – simply push this repository to GitHub and deploy the app by pointing to `app/app.py`. The `requirements.txt` file ensures all dependencies (including OpenAI) are automatically installed.
+
+## Development & tests
+
+Tests live in `tests/test_ttmm.py` and cover indexing, hotspot scoring and search.  To run them:
+
+```bash
+pip install -e .[test]
+pytest -q
+```
+
+Continuous integration is configured via `.github/workflows/ci.yml` to run the test suite on Python 3.8 through 3.12.  If you fork this repository on GitHub the workflow will execute automatically.
+
+## Limitations
+
+* Phase A supports Python only and uses conservative static analysis.  Many dynamic method calls cannot be resolved statically; these appear as `<unresolved>` in the call graph.
+* Hotspot scores require `git` to compute churn – if `git` is not installed or the directory is not a git repository, churn is assumed to be zero.
+* Dynamic tracing only captures calls within the repository root.  Calls to the standard library or external packages are ignored.
+
+Future phases (not implemented here) would add richer language support, deeper type‑aware call resolution and integration with your editor.

zerottmm-0.1.0/README.md

@@ -0,0 +1,145 @@
+# ttmm: Time‑to‑Mental‑Model
+
+`ttmm` is a local‑first code reading assistant designed to reduce the time it takes to load a mental model of a codebase.  It provides static indexing, simple call graph navigation, hotspot detection and dynamic tracing.  You can use it either from the command line or through a Streamlit web UI.
+
+**New**: `ttmm` now supports remote repositories via Git URLs and GitIngest integration, making it easy to analyze any public Python repository without cloning manually.
+
+## Key features (Phase A)
+
+* **Index your repository** – builds a lightweight SQLite database of all Python functions/methods, their definitions, references and coarse call edges using only the standard library.
+* **Remote repository support** – analyze any GitHub, GitLab, or Bitbucket repository directly via URL or GitIngest links without manual cloning.
+* **Hotspot detection** – computes a hotspot score by combining cyclomatic complexity and recent git churn to help you prioritise where to read first.
+* **Static call graph navigation** – shows callers and callees for any symbol using conservative AST analysis.  Attribute calls that cannot be resolved are marked as `<unresolved>`.
+* **Keyword search** – a tiny TF‑IDF engine lets you ask a natural language question and returns a minimal reading set of relevant symbols.
+* **Dynamic tracing** – run a module, function or script with `sys.settrace` to capture the actual call sequence executed at runtime and persist it in the database.
+
+## Installation
+
+Requirements:
+
+* Python 3.8 or later (except 3.9.7 due to Streamlit compatibility)
+* A `git` executable in your `PATH` if you want churn‑based hotspot scores
+
+Install from PyPI:
+
+```bash
+pip install zerottmm
+```
+
+Or install in development mode from this repository:
+
+```bash
+pip install -e .
+```
+
+To enable optional extras:
+
+* `[ui]` – install `streamlit` and `openai` for the web UI with AI features
+* `[test]` – install `pytest` for running the test suite  
+* `[ai]` – install `openai` for AI-enhanced analysis
+
+For example:
+
+```bash
+pip install zerottmm[ui,test]
+```
+
+## Command line usage
+
+After installation a `zerottmm` command will be available:
+
+```bash
+zerottmm index PATH_OR_URL        # index a Python repository (local or remote)
+zerottmm hotspots PATH            # show the top hotspots (default 10)
+zerottmm callers PATH SYMBOL
+zerottmm callees PATH SYMBOL
+zerottmm trace PATH [--module pkg.mod:func | --script file.py] [-- args...]
+zerottmm answer PATH "your question"
+```
+
+* **PATH_OR_URL** – local repository path, Git URL, or GitIngest URL
+* **PATH** – local repository path that has been indexed previously
+* **SYMBOL** – a fully‑qualified name like `package.module:Class.method` or `package.module:function`.
+* **--module** – run a function or module entry point (e.g. `package.module:main`) and trace calls within the repository.
+* **--script** – run an arbitrary Python script in the repository and trace calls.
+
+Use `zerottmm --help` for full documentation.
+
+## Examples
+
+Here are some examples analyzing popular Python repositories:
+
+### Analyze the Python requests library
+```bash
+# Index directly from GitHub
+zerottmm index https://github.com/psf/requests.git
+
+# Find hotspots (complex functions with high churn)
+zerottmm hotspots /tmp/ttmm_repo_*/
+# Output: PreparedRequest.prepare_body, super_len, RequestEncodingMixin._encode_files
+
+# Ask natural language questions  
+zerottmm answer /tmp/ttmm_repo_*/ "how to make HTTP requests"
+# Output: HTTPAdapter.send, Session.request, HTTPAdapter.cert_verify
+```
+
+### Analyze a mathematical optimization library
+```bash  
+# Index a specialized repo via GitIngest URL
+zerottmm index "https://gitingest.com/?url=https://github.com/finite-sample/rank_preserving_calibration"
+
+# Find the main algorithmic components
+zerottmm answer /tmp/ttmm_repo_*/ "main calibration algorithm"
+# Output: calibrate_dykstra, calibrate_admm, _isotonic_regression
+
+# Explore function relationships
+zerottmm callers /tmp/ttmm_repo_*/ "calibrate_dykstra"  
+# Shows all the places this core algorithm is used
+```
+
+### Analyze FastAPI core (subpath example)
+```bash
+# Index just the FastAPI core module using GitIngest subpath
+zerottmm index "https://gitingest.com/?url=https://github.com/tiangolo/fastapi&subpath=fastapi"
+
+# Find entry points and main interfaces
+zerottmm answer /tmp/ttmm_repo_*/ "main application interface"
+```
+
+## Streamlit UI
+
+A simple web UI is provided under `app/app.py`.  To run it locally:
+
+```bash
+pip install -e .[ui]
+streamlit run app/app.py
+```
+
+The app allows you to index repositories (local or remote via GitIngest), explore hotspots, get AI-powered insights, and search interactively. Features include:
+
+* **Repository indexing** from local paths, Git URLs, or GitIngest links
+* **Automatic repository summary** with key metrics and analysis
+* **AI-enhanced analysis** with OpenAI integration (optional)
+* **Hotspot detection** and complexity analysis
+* **Natural language search** over code symbols
+
+The app is designed to run on [Streamlit Community Cloud](https://streamlit.io/cloud) – simply push this repository to GitHub and deploy the app by pointing to `app/app.py`. The `requirements.txt` file ensures all dependencies (including OpenAI) are automatically installed.
+
+## Development & tests
+
+Tests live in `tests/test_ttmm.py` and cover indexing, hotspot scoring and search.  To run them:
+
+```bash
+pip install -e .[test]
+pytest -q
+```
+
+Continuous integration is configured via `.github/workflows/ci.yml` to run the test suite on Python 3.8 through 3.12.  If you fork this repository on GitHub the workflow will execute automatically.
+
+## Limitations
+
+* Phase A supports Python only and uses conservative static analysis.  Many dynamic method calls cannot be resolved statically; these appear as `<unresolved>` in the call graph.
+* Hotspot scores require `git` to compute churn – if `git` is not installed or the directory is not a git repository, churn is assumed to be zero.
+* Dynamic tracing only captures calls within the repository root.  Calls to the standard library or external packages are ignored.
+
+Future phases (not implemented here) would add richer language support, deeper type‑aware call resolution and integration with your editor.

zerottmm-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=65", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zerottmm"
+version = "0.1.0"
+description = "Time‑to‑Mental‑Model: a local‑first code reading assistant (Phase A)"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "Gaurav Sood", email = "contact@gsood.com" }
+]
+license = "MIT"
+keywords = ["code-analysis", "static-analysis", "code-reading", "python", "ast"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Code Generators",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+]
+
+# core dependencies – pure standard library so far
+dependencies = []
+
+[project.optional-dependencies]
+# extras for the Streamlit UI and testing
+ui = ["streamlit>=1.23", "openai>=1.0.0"]  # Include OpenAI for UI
+test = ["pytest"]
+ai = ["openai>=1.0.0"]  # Future AI integration
+all = ["streamlit>=1.23", "pytest", "openai>=1.0.0"]
+
+[project.scripts]
+zerottmm = "zerottmm.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["zerottmm*"]
+exclude = ["app*"]

zerottmm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zerottmm-0.1.0/tests/test_ttmm.py

@@ -0,0 +1,91 @@
+"""Basic tests for the ttmm package.
+
+These tests create a small temporary repository on the fly, index it,
+and verify that symbol extraction, call resolution, hotspot scoring and
+search behave as expected.  They are intentionally simple and do not
+cover every corner case; the goal is to provide smoke coverage for
+continuous integration.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+import textwrap
+
+import pytest
+
+from zerottmm import index as ttmm_index
+from zerottmm import store as ttmm_store
+from zerottmm import search as ttmm_search
+
+
+def create_sample_repo(tmp_path) -> str:
+    """Create a small sample Python project for testing.
+
+    The project has two files:
+
+    * ``alpha.py`` defines ``foo`` which calls ``bar``; ``bar`` does nothing.
+    * ``beta.py`` defines a class ``Widget`` with method ``ping`` which
+      calls ``foo``.
+    """
+    alpha = textwrap.dedent(
+        """
+        def foo():
+            '''Foo does something and calls bar.'''
+            bar()
+
+        def bar():
+            return None
+        """
+    )
+    beta = textwrap.dedent(
+        """
+        class Widget:
+            def ping(self):
+                # ping calls foo from alpha
+                from alpha import foo
+                foo()
+        """
+    )
+    repo = tmp_path
+    (repo / "alpha.py").write_text(alpha)
+    (repo / "beta.py").write_text(beta)
+    return str(repo)
+
+
+def test_index_and_hotspots_and_call_graph(tmp_path):
+    repo = create_sample_repo(tmp_path)
+    ttmm_index.index_repo(repo)
+    conn = ttmm_store.connect(repo)
+    try:
+        # Check that foo and bar and Widget.ping are present
+        sid_foo = ttmm_store.resolve_symbol(conn, "alpha:foo")
+        sid_bar = ttmm_store.resolve_symbol(conn, "alpha:bar")
+        sid_ping = ttmm_store.resolve_symbol(conn, "beta:Widget.ping")
+        assert sid_foo and sid_bar and sid_ping
+        # Check callees: foo should call bar
+        callees = ttmm_store.get_callees(conn, sid_foo)
+        assert any(name == "alpha:bar" and not unresolved for name, path, unresolved in callees)
+        # Check callers: bar should have foo as caller
+        callers_bar = ttmm_store.get_callers(conn, sid_bar)
+        assert any(name == "alpha:foo" for name, _ in callers_bar)
+        # Hotspots should include these three symbols
+        hotspots = ttmm_store.get_hotspots(conn, limit=10)
+        qualnames = [row["qualname"] for row in hotspots]
+        assert "alpha:foo" in qualnames
+        assert "alpha:bar" in qualnames
+        assert "beta:Widget.ping" in qualnames
+    finally:
+        ttmm_store.close(conn)
+
+
+def test_search_answers(tmp_path):
+    repo = create_sample_repo(tmp_path)
+    ttmm_index.index_repo(repo)
+    # Ask about bar
+    results = ttmm_search.answer_question(repo, "call bar", top=3, include_scores=False)
+    # Expect foo to appear because foo calls bar
+    qualnames = [r[0] for r in results]
+    assert any(qn.endswith(":foo") for qn in qualnames)
+    assert any(qn.endswith(":bar") for qn in qualnames)

zerottmm-0.1.0/zerottmm/__init__.py

@@ -0,0 +1,38 @@
+"""Top‑level package for ttmm.
+
+`ttmm` (Time‑to‑Mental‑Model) helps you build a mental model of a Python codebase
+faster.  It can index a repository, compute hotspots, navigate static call graphs,
+run dynamic traces and answer natural language questions about your code.  The core
+functionality lives in submodules:
+
+* `ttmm.index` – parse and index a Python repository
+* `ttmm.store` – SQLite persistence layer
+* `ttmm.metrics` – compute cyclomatic complexity and other metrics
+* `ttmm.gitutils` – git churn calculations
+* `ttmm.trace` – runtime tracing using `sys.settrace`
+* `ttmm.search` – tiny TF‑IDF search over your codebase
+* `ttmm.cli` – command line entry point
+
+Importing this package will expose the `__version__` attribute.  For most use cases
+you should call into `ttmm.cli` via the `ttmm` command line, or import functions
+from the specific submodules.
+"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:  # pragma: no cover - during development version metadata may be missing
+    __version__ = version(__name__)
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = [
+    "index",
+    "store",
+    "metrics",
+    "gitutils",
+    "trace",
+    "search",
+    "gitingest",
+    "ai_analysis",
+    "cli",
+]

zerottmm-0.1.0/zerottmm/ai_analysis.py

@@ -0,0 +1,149 @@
+"""AI-powered code analysis using OpenAI API.
+
+This module provides AI-enhanced analysis capabilities for ttmm,
+allowing users to get natural language explanations and insights
+about their codebases using OpenAI's GPT models.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+
+def analyze_code_with_ai(
+    api_key: str,
+    analysis_type: str,
+    hotspots_context: List[str],
+    repo_info: Dict,
+    custom_prompt: Optional[str] = None,
+) -> str:
+    """Analyze code using OpenAI API.
+
+    Parameters
+    ----------
+    api_key : str
+        OpenAI API key
+    analysis_type : str
+        Type of analysis to perform
+    hotspots_context : List[str]
+        List of hotspot descriptions
+    repo_info : Dict
+        Repository metadata
+    custom_prompt : str, optional
+        Custom analysis prompt
+
+    Returns
+    -------
+    str
+        AI analysis result
+    """
+    try:
+        import openai
+    except ImportError:
+        return ("❌ **OpenAI library not installed**\n\n"
+                "Please install it with: `pip install openai`")
+
+    # Set up OpenAI client
+    client = openai.OpenAI(api_key=api_key)
+
+    # Prepare context
+    repo_context = f"""
+Repository Information:
+- Path: {repo_info.get('path', 'Unknown')}
+- Remote URL: {repo_info.get('remote_url', 'Local repository')}
+- Branch: {repo_info.get('branch', 'Unknown')}
+- Commit: {repo_info.get('commit', 'Unknown')}
+
+Top Code Hotspots (high complexity functions):
+{chr(10).join(hotspots_context[:5])}
+"""
+
+    # Define analysis prompts
+    analysis_prompts = {
+        "Explain hotspots": (
+            "Analyze the code hotspots listed above. Explain what makes these functions "
+            "complex and suggest potential improvements or areas that might need attention. "
+            "Focus on maintainability and potential refactoring opportunities."
+        ),
+        "Summarize architecture": (
+            "Based on the hotspots and repository information, provide a high-level "
+            "architectural summary of this codebase. Identify the main components, "
+            "patterns, and overall structure."
+        ),
+        "Identify design patterns": (
+            "Analyze the code hotspots and identify any design patterns being used. "
+            "Comment on the appropriateness of these patterns and suggest alternatives "
+            "if beneficial."
+        ),
+        "Find potential issues": (
+            "Review the code hotspots for potential issues like performance bottlenecks, "
+            "security concerns, maintainability problems, or technical debt. Provide "
+            "specific recommendations."
+        ),
+        "Custom analysis": custom_prompt or "Provide a general analysis of the codebase.",
+    }
+
+    prompt = analysis_prompts.get(analysis_type, analysis_prompts["Custom analysis"])
+
+    try:
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are a senior software engineer helping to analyze a Python "
+                        "codebase. Provide clear, actionable insights based on the code "
+                        "metrics and hotspots provided. Be concise but thorough."
+                    )
+                },
+                {
+                    "role": "user",
+                    "content": f"{repo_context}\n\nAnalysis Request: {prompt}"
+                }
+            ],
+            max_tokens=1000,
+            temperature=0.3,
+        )
+
+        return response.choices[0].message.content or "No analysis generated."
+
+    except openai.OpenAIError as e:
+        return f"❌ **OpenAI API Error**: {str(e)}"
+    except Exception as e:
+        return f"❌ **Analysis Error**: {str(e)}"
+
+
+def test_openai_connection(api_key: str) -> tuple[bool, str]:
+    """Test if OpenAI API key is valid.
+
+    Parameters
+    ----------
+    api_key : str
+        OpenAI API key to test
+
+    Returns
+    -------
+    tuple[bool, str]
+        (success, message)
+    """
+    try:
+        import openai
+    except ImportError:
+        return False, "OpenAI library not installed"
+
+    try:
+        client = openai.OpenAI(api_key=api_key)
+        # Make a minimal API call to test the key
+        client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[{"role": "user", "content": "Hello"}],
+            max_tokens=5
+        )
+        return True, "API key is valid"
+    except openai.AuthenticationError:
+        return False, "Invalid API key"
+    except openai.OpenAIError as e:
+        return False, f"OpenAI API error: {str(e)}"
+    except Exception as e:
+        return False, f"Connection error: {str(e)}"