codeanalyzer-python 0.1.4__tar.gz → 0.1.6__tar.gz

{codeanalyzer_python-0.1.4 → codeanalyzer_python-0.1.6}/PKG-INFO

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: codeanalyzer-python
-Version: 0.1.4
+Version: 0.1.6
 Summary: Static Analysis on Python source code using Jedi, CodeQL and Treesitter.
 Author-email: Rahul Krishna <i.m.ralk@gmail.com>
 License-File: LICENSE
 License-File: NOTICE
-Requires-Python: >=3.12
-Requires-Dist: astor>=0.8.1
+Requires-Python: ==3.10.*
 Requires-Dist: jedi>=0.19.2
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: msgpack>=1.1.1
-Requires-Dist: networkx>=3.5
+Requires-Dist: networkx>=3.4.2
 Requires-Dist: pandas>=2.3.1
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: requests>=2.32.4
@@ -166,6 +165,193 @@ This project uses [uv](https://docs.astral.sh/uv/) for dependency management dur
 ### Development Setup
 
 1. Install [uv](https://docs.astral.sh/uv/getting-started/installation/)
+![logo](https://github.com/codellm-devkit/codeanalyzer-python/blob/main/docs/assets/logo.png?raw=true)
+
+# A Python Static Analysis Toolkit (and Library)
+
+A comprehensive static analysis tool for Python source code that provides symbol table generation, call graph analysis, and semantic analysis using Jedi, CodeQL, and Tree-sitter.
+
+## Installation
+
+```bash
+pip install codeanalyzer-python
+```
+
+### Prerequisites
+
+- Python 3.12 or higher
+
+#### System Package Requirements
+
+The tool creates virtual environments internally using Python's built-in `venv` module.
+
+**Ubuntu/Debian systems:**
+```bash
+sudo apt update
+sudo apt install python3.12-venv python3-dev build-essential
+```
+
+**Fedora/RHEL/CentOS systems:**
+```bash
+sudo dnf group install "Development Tools"
+sudo dnf install python3-pip python3-venv python3-devel
+```
+or on older versions:
+```bash
+sudo yum groupinstall "Development Tools"
+sudo yum install python3-pip python3-venv python3-devel
+```
+
+**macOS systems:**
+```bash
+# Install Xcode Command Line Tools (for compilation)
+xcode-select --install
+
+# If using Homebrew Python (recommended)
+brew install python@3.12
+
+# If using pyenv (popular Python version manager)
+# First ensure pyenv is properly installed and configured
+pyenv install 3.12.0  # or latest 3.12.x version
+pyenv global 3.12.0   # or pyenv local 3.12.0 for project-specific
+
+# If using system Python, you may need to install certificates
+/Applications/Python\ 3.12/Install\ Certificates.command
+```
+
+> **Note:** These packages are required as the tool uses Python's built-in `venv` module to create isolated environments for analysis.
+
+## Usage
+
+The codeanalyzer provides a command-line interface for performing static analysis on Python projects.
+
+### Basic Usage
+
+```bash
+codeanalyzer --input /path/to/python/project
+```
+
+### Command Line Options
+
+To view the available options and commands, run `codeanalyzer --help`. You should see output similar to the following:
+
+```bash
+❯ codeanalyzer --help
+
+ Usage: codeanalyzer [OPTIONS] COMMAND [ARGS]...
+
+ Static Analysis on Python source code using Jedi, CodeQL and Tree sitter.
+
+
+╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ *  --input           -i                  PATH     Path to the project root directory. [default: None] [required]   │
+│    --output          -o                  PATH     Output directory for artifacts. [default: None]                  │
+│    --format          -f           [json|msgpack]  Output format: json or msgpack. [default: json].                 │
+│    --analysis-level  -a                  INTEGER  1: symbol table, 2: call graph. [default: 1]                     │
+│    --codeql              --no-codeql              Enable CodeQL-based analysis. [default: no-codeql]               │
+│    --eager               --lazy                   Enable eager or lazy analysis. Defaults to lazy. [default: lazy] │
+│    --cache-dir       -c                  PATH     Directory to store analysis cache. [default: None]               │
+│    --clear-cache         --keep-cache             Clear cache after analysis. [default: clear-cache]               │
+│                      -v                  INTEGER  Increase verbosity: -v, -vv, -vvv [default: 0]                   │
+│    --help                                         Show this message and exit.                                      │
+╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+```
+
+### Examples
+
+1. **Basic analysis with symbol table:**
+   ```bash
+   codeanalyzer --input ./my-python-project
+   ```
+
+   This will print the symbol table to stdout in JSON format to the standard output. If you want to save the output, you can use the `--output` option.
+
+   ```bash
+   codeanalyzer --input ./my-python-project --output /path/to/analysis-results
+   ```
+
+   Now, you can find the analysis results in `analysis.json` in the specified directory.
+
+2. **Toggle analysis levels with `--analysis-level`:**
+   ```bash
+   codeanalyzer --input ./my-python-project --analysis-level 1 # Symbol table only
+   ```
+   Call graph analysis can be enabled by setting the level to `2`:
+   ```bash
+   codeanalyzer --input ./my-python-project --analysis-level 2 # Symbol table + Call graph
+   ```
+   ***Note: The `--analysis-level=2` is not yet implemented in this version.***
+
+3. **Analysis with CodeQL enabled:**
+   ```bash
+   codeanalyzer --input ./my-python-project --codeql
+   ```
+    This will perform CodeQL-based analysis in addition to the standard symbol table generation.
+
+    ***Note: Not yet fully implemented. Please refrain from using this option until further notice.***
+
+4. **Eager analysis with custom cache directory:**
+   ```bash
+   codeanalyzer --input ./my-python-project --eager --cache-dir /path/to/custom-cache
+   ```
+    This will rebuild the analysis cache at every run and store it in `/path/to/custom-cache/.codeanalyzer`. The cache will be cleared by default after analysis unless you specify `--keep-cache`.
+
+    If you provide --cache-dir, the cache will be stored in that directory. If not specified, it defaults to `.codeanalyzer` in the current working directory (`$PWD`).
+
+5. **Save output in msgpack format:**
+   ```bash
+   codeanalyzer --input ./my-python-project --output /path/to/analysis-results --format msgpack
+   ```
+
+### Output
+
+By default, analysis results are printed to stdout in JSON format. When using the `--output` option, results are saved to `analysis.json` in the specified directory.
+
+## Development
+
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management during development.
+
+### Development Setup
+
+1. Install [uv](https://docs.astral.sh/uv/getting-started/installation/)
+
+2. Clone the repository:
+   ```bash
+   git clone https://github.com/codellm-devkit/codeanalyzer-python
+   cd codeanalyzer-python
+   ```
+
+3. Install dependencies using uv:
+   ```bash
+   uv sync --all-groups
+   ```
+   This will install all dependencies including development and test dependencies.
+
+### Running from Source
+
+When developing, you can run the tool directly from source:
+
+```bash
+uv run codeanalyzer --input /path/to/python/project
+```
+
+### Running Tests
+
+```bash
+uv run pytest --pspec -s
+```
+
+### Development Dependencies
+
+The project includes additional dependency groups for development:
+
+- **test**: pytest and related testing tools
+- **dev**: development tools like ipdb
+
+Install all groups with:
+```bash
+uv sync --all-groups
+```
 
 2. Clone the repository:
    ```bash

codeanalyzer_python-0.1.6/README.md

@@ -0,0 +1,373 @@
+![logo](https://github.com/codellm-devkit/codeanalyzer-python/blob/main/docs/assets/logo.png?raw=true)
+
+# A Python Static Analysis Toolkit (and Library)
+
+A comprehensive static analysis tool for Python source code that provides symbol table generation, call graph analysis, and semantic analysis using Jedi, CodeQL, and Tree-sitter.
+
+## Installation
+
+```bash
+pip install codeanalyzer-python
+```
+
+### Prerequisites
+
+- Python 3.12 or higher
+
+#### System Package Requirements
+
+The tool creates virtual environments internally using Python's built-in `venv` module.
+
+**Ubuntu/Debian systems:**
+```bash
+sudo apt update
+sudo apt install python3.12-venv python3-dev build-essential
+```
+
+**Fedora/RHEL/CentOS systems:**
+```bash
+sudo dnf group install "Development Tools"
+sudo dnf install python3-pip python3-venv python3-devel
+```
+or on older versions:
+```bash
+sudo yum groupinstall "Development Tools"
+sudo yum install python3-pip python3-venv python3-devel
+```
+
+**macOS systems:**
+```bash
+# Install Xcode Command Line Tools (for compilation)
+xcode-select --install
+
+# If using Homebrew Python (recommended)
+brew install python@3.12
+
+# If using pyenv (popular Python version manager)
+# First ensure pyenv is properly installed and configured
+pyenv install 3.12.0  # or latest 3.12.x version
+pyenv global 3.12.0   # or pyenv local 3.12.0 for project-specific
+
+# If using system Python, you may need to install certificates
+/Applications/Python\ 3.12/Install\ Certificates.command
+```
+
+> **Note:** These packages are required as the tool uses Python's built-in `venv` module to create isolated environments for analysis.
+
+## Usage
+
+The codeanalyzer provides a command-line interface for performing static analysis on Python projects.
+
+### Basic Usage
+
+```bash
+codeanalyzer --input /path/to/python/project
+```
+
+### Command Line Options
+
+To view the available options and commands, run `codeanalyzer --help`. You should see output similar to the following:
+
+```bash
+❯ codeanalyzer --help
+
+ Usage: codeanalyzer [OPTIONS] COMMAND [ARGS]...
+
+ Static Analysis on Python source code using Jedi, CodeQL and Tree sitter.
+
+
+╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ *  --input           -i                  PATH     Path to the project root directory. [default: None] [required]   │
+│    --output          -o                  PATH     Output directory for artifacts. [default: None]                  │
+│    --analysis-level  -a                  INTEGER  1: symbol table, 2: call graph. [default: 1]                     │
+│    --codeql              --no-codeql              Enable CodeQL-based analysis. [default: no-codeql]               │
+│    --eager               --lazy                   Enable eager or lazy analysis. Defaults to lazy. [default: lazy] │
+│    --cache-dir       -c                  PATH     Directory to store analysis cache. [default: None]               │
+│    --clear-cache         --keep-cache             Clear cache after analysis. [default: clear-cache]               │
+│                      -v                  INTEGER  Increase verbosity: -v, -vv, -vvv [default: 0]                   │
+│    --help                                         Show this message and exit.                                      │
+╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+```
+
+### Examples
+
+1. **Basic analysis with symbol table:**
+   ```bash
+   codeanalyzer --input ./my-python-project
+   ```
+
+   This will print the symbol table to stdout in JSON format to the standard output. If you want to save the output, you can use the `--output` option.
+
+   ```bash
+   codeanalyzer --input ./my-python-project --output /path/to/analysis-results
+   ```
+
+   Now, you can find the analysis results in `analysis.json` in the specified directory.
+
+2. **Toggle analysis levels with `--analysis-level`:**
+   ```bash
+   codeanalyzer --input ./my-python-project --analysis-level 1 # Symbol table only
+   ```
+   Call graph analysis can be enabled by setting the level to `2`:
+   ```bash
+   codeanalyzer --input ./my-python-project --analysis-level 2 # Symbol table + Call graph
+   ```
+   ***Note: The `--analysis-level=2` is not yet implemented in this version.***
+
+3. **Analysis with CodeQL enabled:**
+   ```bash
+   codeanalyzer --input ./my-python-project --codeql
+   ```
+    This will perform CodeQL-based analysis in addition to the standard symbol table generation.
+
+    ***Note: Not yet fully implemented. Please refrain from using this option until further notice.***
+
+4. **Eager analysis with custom cache directory:**
+   ```bash
+   codeanalyzer --input ./my-python-project --eager --cache-dir /path/to/custom-cache
+   ```
+    This will rebuild the analysis cache at every run and store it in `/path/to/custom-cache/.codeanalyzer`. The cache will be cleared by default after analysis unless you specify `--keep-cache`.
+
+    If you provide --cache-dir, the cache will be stored in that directory. If not specified, it defaults to `.codeanalyzer` in the current working directory (`$PWD`).
+
+5. **Quiet mode (minimal output):**
+   ```bash
+   codeanalyzer --input /path/to/my-python-project --quiet
+   ```
+
+### Output
+
+By default, analysis results are printed to stdout in JSON format. When using the `--output` option, results are saved to `analysis.json` in the specified directory.
+
+## Development
+
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management during development.
+
+### Development Setup
+
+1. Install [uv](https://docs.astral.sh/uv/getting-started/installation/)
+![logo](https://github.com/codellm-devkit/codeanalyzer-python/blob/main/docs/assets/logo.png?raw=true)
+
+# A Python Static Analysis Toolkit (and Library)
+
+A comprehensive static analysis tool for Python source code that provides symbol table generation, call graph analysis, and semantic analysis using Jedi, CodeQL, and Tree-sitter.
+
+## Installation
+
+```bash
+pip install codeanalyzer-python
+```
+
+### Prerequisites
+
+- Python 3.12 or higher
+
+#### System Package Requirements
+
+The tool creates virtual environments internally using Python's built-in `venv` module.
+
+**Ubuntu/Debian systems:**
+```bash
+sudo apt update
+sudo apt install python3.12-venv python3-dev build-essential
+```
+
+**Fedora/RHEL/CentOS systems:**
+```bash
+sudo dnf group install "Development Tools"
+sudo dnf install python3-pip python3-venv python3-devel
+```
+or on older versions:
+```bash
+sudo yum groupinstall "Development Tools"
+sudo yum install python3-pip python3-venv python3-devel
+```
+
+**macOS systems:**
+```bash
+# Install Xcode Command Line Tools (for compilation)
+xcode-select --install
+
+# If using Homebrew Python (recommended)
+brew install python@3.12
+
+# If using pyenv (popular Python version manager)
+# First ensure pyenv is properly installed and configured
+pyenv install 3.12.0  # or latest 3.12.x version
+pyenv global 3.12.0   # or pyenv local 3.12.0 for project-specific
+
+# If using system Python, you may need to install certificates
+/Applications/Python\ 3.12/Install\ Certificates.command
+```
+
+> **Note:** These packages are required as the tool uses Python's built-in `venv` module to create isolated environments for analysis.
+
+## Usage
+
+The codeanalyzer provides a command-line interface for performing static analysis on Python projects.
+
+### Basic Usage
+
+```bash
+codeanalyzer --input /path/to/python/project
+```
+
+### Command Line Options
+
+To view the available options and commands, run `codeanalyzer --help`. You should see output similar to the following:
+
+```bash
+❯ codeanalyzer --help
+
+ Usage: codeanalyzer [OPTIONS] COMMAND [ARGS]...
+
+ Static Analysis on Python source code using Jedi, CodeQL and Tree sitter.
+
+
+╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ *  --input           -i                  PATH     Path to the project root directory. [default: None] [required]   │
+│    --output          -o                  PATH     Output directory for artifacts. [default: None]                  │
+│    --format          -f           [json|msgpack]  Output format: json or msgpack. [default: json].                 │
+│    --analysis-level  -a                  INTEGER  1: symbol table, 2: call graph. [default: 1]                     │
+│    --codeql              --no-codeql              Enable CodeQL-based analysis. [default: no-codeql]               │
+│    --eager               --lazy                   Enable eager or lazy analysis. Defaults to lazy. [default: lazy] │
+│    --cache-dir       -c                  PATH     Directory to store analysis cache. [default: None]               │
+│    --clear-cache         --keep-cache             Clear cache after analysis. [default: clear-cache]               │
+│                      -v                  INTEGER  Increase verbosity: -v, -vv, -vvv [default: 0]                   │
+│    --help                                         Show this message and exit.                                      │
+╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+```
+
+### Examples
+
+1. **Basic analysis with symbol table:**
+   ```bash
+   codeanalyzer --input ./my-python-project
+   ```
+
+   This will print the symbol table to stdout in JSON format to the standard output. If you want to save the output, you can use the `--output` option.
+
+   ```bash
+   codeanalyzer --input ./my-python-project --output /path/to/analysis-results
+   ```
+
+   Now, you can find the analysis results in `analysis.json` in the specified directory.
+
+2. **Toggle analysis levels with `--analysis-level`:**
+   ```bash
+   codeanalyzer --input ./my-python-project --analysis-level 1 # Symbol table only
+   ```
+   Call graph analysis can be enabled by setting the level to `2`:
+   ```bash
+   codeanalyzer --input ./my-python-project --analysis-level 2 # Symbol table + Call graph
+   ```
+   ***Note: The `--analysis-level=2` is not yet implemented in this version.***
+
+3. **Analysis with CodeQL enabled:**
+   ```bash
+   codeanalyzer --input ./my-python-project --codeql
+   ```
+    This will perform CodeQL-based analysis in addition to the standard symbol table generation.
+
+    ***Note: Not yet fully implemented. Please refrain from using this option until further notice.***
+
+4. **Eager analysis with custom cache directory:**
+   ```bash
+   codeanalyzer --input ./my-python-project --eager --cache-dir /path/to/custom-cache
+   ```
+    This will rebuild the analysis cache at every run and store it in `/path/to/custom-cache/.codeanalyzer`. The cache will be cleared by default after analysis unless you specify `--keep-cache`.
+
+    If you provide --cache-dir, the cache will be stored in that directory. If not specified, it defaults to `.codeanalyzer` in the current working directory (`$PWD`).
+
+5. **Save output in msgpack format:**
+   ```bash
+   codeanalyzer --input ./my-python-project --output /path/to/analysis-results --format msgpack
+   ```
+
+### Output
+
+By default, analysis results are printed to stdout in JSON format. When using the `--output` option, results are saved to `analysis.json` in the specified directory.
+
+## Development
+
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management during development.
+
+### Development Setup
+
+1. Install [uv](https://docs.astral.sh/uv/getting-started/installation/)
+
+2. Clone the repository:
+   ```bash
+   git clone https://github.com/codellm-devkit/codeanalyzer-python
+   cd codeanalyzer-python
+   ```
+
+3. Install dependencies using uv:
+   ```bash
+   uv sync --all-groups
+   ```
+   This will install all dependencies including development and test dependencies.
+
+### Running from Source
+
+When developing, you can run the tool directly from source:
+
+```bash
+uv run codeanalyzer --input /path/to/python/project
+```
+
+### Running Tests
+
+```bash
+uv run pytest --pspec -s
+```
+
+### Development Dependencies
+
+The project includes additional dependency groups for development:
+
+- **test**: pytest and related testing tools
+- **dev**: development tools like ipdb
+
+Install all groups with:
+```bash
+uv sync --all-groups
+```
+
+2. Clone the repository:
+   ```bash
+   git clone https://github.com/codellm-devkit/codeanalyzer-python
+   cd codeanalyzer-python
+   ```
+
+3. Install dependencies using uv:
+   ```bash
+   uv sync --all-groups
+   ```
+   This will install all dependencies including development and test dependencies.
+
+### Running from Source
+
+When developing, you can run the tool directly from source:
+
+```bash
+uv run codeanalyzer --input /path/to/python/project
+```
+
+### Running Tests
+
+```bash
+uv run pytest --pspec -s
+```
+
+### Development Dependencies
+
+The project includes additional dependency groups for development:
+
+- **test**: pytest and related testing tools
+- **dev**: development tools like ipdb
+
+Install all groups with:
+```bash
+uv sync --all-groups
+```

codeanalyzer_python-0.1.6/codeanalyzer/__init__.py

@@ -0,0 +1,5 @@
+"""Python code analyzer library."""
+
+from codeanalyzer.core import Codeanalyzer
+
+__all__ = ["Codeanalyzer"]

{codeanalyzer_python-0.1.4 → codeanalyzer_python-0.1.6}/codeanalyzer/__main__.py

@@ -1,16 +1,11 @@
 from pathlib import Path
 from typing import Annotated, Optional
-from enum import Enum
 
 import typer
 
-from codeanalyzer.core import AnalyzerCore
+from codeanalyzer.core import Codeanalyzer
 from codeanalyzer.utils import _set_log_level, logger
-
-
-class OutputFormat(str, Enum):
-    JSON = "json"
-    MSGPACK = "msgpack"
+from codeanalyzer.config import OutputFormat
 
 
 def main(
@@ -67,7 +62,7 @@ def main(
         logger.error(f"Input path '{input}' does not exist.")
         raise typer.Exit(code=1)
 
-    with AnalyzerCore(
+    with Codeanalyzer(
         input, analysis_level, using_codeql, rebuild_analysis, cache_dir, clear_cache
     ) as analyzer:
         artifacts = analyzer.analyze()
@@ -92,8 +87,10 @@ def _write_output(artifacts, output_dir: Path, format: OutputFormat):
     """Write artifacts to file in the specified format."""
     if format == OutputFormat.JSON:
         output_file = output_dir / "analysis.json"
+        # Use Pydantic's json() with separators for compact output
+        json_str = artifacts.model_dump_json(indent=None)
         with output_file.open("w") as f:
-            f.write(artifacts.model_dump_json(separators=(",", ":")))
+            f.write(json_str)
         logger.info(f"Analysis saved to {output_file}")
 
     elif format == OutputFormat.MSGPACK:

{codeanalyzer_python-0.1.4 → codeanalyzer_python-0.1.6}/codeanalyzer/core.py

@@ -13,7 +13,7 @@ from codeanalyzer.syntactic_analysis.symbol_table_builder import SymbolTableBuil
 from codeanalyzer.utils import logger
 
 
-class AnalyzerCore:
+class Codeanalyzer:
     """Core functionality for CodeQL analysis.
 
     Args:
@@ -196,7 +196,7 @@ class AnalyzerCore:
             f"a working Python interpreter that can create virtual environments."
         )
 
-    def __enter__(self) -> "AnalyzerCore":
+    def __enter__(self) -> "Codeanalyzer":
         # If no virtualenv is provided, try to create one using requirements.txt or pyproject.toml
         venv_path = self.cache_dir / self.project_dir.name / "virtualenv"
         # Ensure the cache directory exists for this project

{codeanalyzer_python-0.1.4 → codeanalyzer_python-0.1.6}/codeanalyzer/syntactic_analysis/symbol_table_builder.py

@@ -5,7 +5,6 @@ from io import StringIO
 from pathlib import Path
 from typing import Dict, List, Optional
 
-import astor
 import jedi
 from jedi.api import Script
 from jedi.api.project import Project
@@ -183,7 +182,7 @@ class SymbolTableBuilder:
                 f"{script.path.__str__().replace('/', '.').replace('.py', '')}.{class_node.name}",
             )
 
-        code: str = astor.to_source(class_node).strip()
+        code: str = ast.unparse(class_node).strip()
 
         py_class = (
             PyClass.builder()
@@ -243,7 +242,7 @@ class SymbolTableBuilder:
                         child, "end_lineno", start_line + len(child.body)
                     )
                     code_start_line = child.body[0].lineno if child.body else start_line
-                    code = astor.to_source(child).strip()
+                    code: str = ast.unparse(child).strip()
                     decorators = [ast.unparse(d) for d in child.decorator_list]
 
                     try:
@@ -504,7 +503,9 @@ class SymbolTableBuilder:
 
         return params
 
-    def _accessed_symbols(self, fn_node: ast.FunctionDef, script: Script) -> List[str]:
+    def _accessed_symbols(
+        self, fn_node: ast.FunctionDef, script: Script
+    ) -> List[PySymbol]:
         """Analyzes the function body to extract all accessed symbols."""
         symbols = []
         for node in ast.walk(fn_node):

{codeanalyzer_python-0.1.4 → codeanalyzer_python-0.1.6}/pyproject.toml

@@ -1,19 +1,18 @@
 [project]
 name = "codeanalyzer-python"
-version = "0.1.4"
+version = "0.1.6"
 description = "Static Analysis on Python source code using Jedi, CodeQL and Treesitter."
 readme = "README.md"
 authors = [
     { name = "Rahul Krishna", email = "i.m.ralk@gmail.com" }
 ]
-requires-python = ">=3.12"
+requires-python = "==3.10.*"
 
 dependencies = [
-    "astor>=0.8.1",
     "jedi>=0.19.2",
     "loguru>=0.7.3",
     "msgpack>=1.1.1",
-    "networkx>=3.5",
+    "networkx>=3.4.2",
     "pandas>=2.3.1",
     "pydantic>=2.11.7",
     "requests>=2.32.4",
@@ -54,4 +53,37 @@ include = [
 ]
 
 [tool.pytest.ini_options]
-testpaths = ["tests"]
+addopts = [
+    "-p", "coverage",
+    "--cov=codeanalyzer",
+    "--cov-report=html",
+    "--cov-report=term-missing",
+    "--cov-fail-under=40"
+]
+testpaths = ["test"]
+
+[tool.coverage.run]
+source = ["codeanalyzer"]
+branch = true
+omit = [
+    "*/tests/*",
+    "*/test_*",
+    "*/__pycache__/*",
+    "*/venv/*",
+    "*/.venv/*",
+    "codeanalyzer/semantic_analysis/*"
+]
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:"
+]
+
+[tool.coverage.html]
+directory = "htmlcov"

codeanalyzer_python-0.1.4/README.md

@@ -1,186 +0,0 @@
-![logo](https://github.com/codellm-devkit/codeanalyzer-python/blob/main/docs/assets/logo.png?raw=true)
-
-# A Python Static Analysis Toolkit (and Library)
-
-A comprehensive static analysis tool for Python source code that provides symbol table generation, call graph analysis, and semantic analysis using Jedi, CodeQL, and Tree-sitter.
-
-## Installation
-
-```bash
-pip install codeanalyzer-python
-```
-
-### Prerequisites
-
-- Python 3.12 or higher
-
-#### System Package Requirements
-
-The tool creates virtual environments internally using Python's built-in `venv` module.
-
-**Ubuntu/Debian systems:**
-```bash
-sudo apt update
-sudo apt install python3.12-venv python3-dev build-essential
-```
-
-**Fedora/RHEL/CentOS systems:**
-```bash
-sudo dnf group install "Development Tools"
-sudo dnf install python3-pip python3-venv python3-devel
-```
-or on older versions:
-```bash
-sudo yum groupinstall "Development Tools"
-sudo yum install python3-pip python3-venv python3-devel
-```
-
-**macOS systems:**
-```bash
-# Install Xcode Command Line Tools (for compilation)
-xcode-select --install
-
-# If using Homebrew Python (recommended)
-brew install python@3.12
-
-# If using pyenv (popular Python version manager)
-# First ensure pyenv is properly installed and configured
-pyenv install 3.12.0  # or latest 3.12.x version
-pyenv global 3.12.0   # or pyenv local 3.12.0 for project-specific
-
-# If using system Python, you may need to install certificates
-/Applications/Python\ 3.12/Install\ Certificates.command
-```
-
-> **Note:** These packages are required as the tool uses Python's built-in `venv` module to create isolated environments for analysis.
-
-## Usage
-
-The codeanalyzer provides a command-line interface for performing static analysis on Python projects.
-
-### Basic Usage
-
-```bash
-codeanalyzer --input /path/to/python/project
-```
-
-### Command Line Options
-
-To view the available options and commands, run `codeanalyzer --help`. You should see output similar to the following:
-
-```bash
-❯ codeanalyzer --help
-
- Usage: codeanalyzer [OPTIONS] COMMAND [ARGS]...
-
- Static Analysis on Python source code using Jedi, CodeQL and Tree sitter.
-
-
-╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ *  --input           -i                  PATH     Path to the project root directory. [default: None] [required]   │
-│    --output          -o                  PATH     Output directory for artifacts. [default: None]                  │
-│    --analysis-level  -a                  INTEGER  1: symbol table, 2: call graph. [default: 1]                     │
-│    --codeql              --no-codeql              Enable CodeQL-based analysis. [default: no-codeql]               │
-│    --eager               --lazy                   Enable eager or lazy analysis. Defaults to lazy. [default: lazy] │
-│    --cache-dir       -c                  PATH     Directory to store analysis cache. [default: None]               │
-│    --clear-cache         --keep-cache             Clear cache after analysis. [default: clear-cache]               │
-│                      -v                  INTEGER  Increase verbosity: -v, -vv, -vvv [default: 0]                   │
-│    --help                                         Show this message and exit.                                      │
-╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-```
-
-### Examples
-
-1. **Basic analysis with symbol table:**
-   ```bash
-   codeanalyzer --input ./my-python-project
-   ```
-
-   This will print the symbol table to stdout in JSON format to the standard output. If you want to save the output, you can use the `--output` option.
-
-   ```bash
-   codeanalyzer --input ./my-python-project --output /path/to/analysis-results
-   ```
-
-   Now, you can find the analysis results in `analysis.json` in the specified directory.
-
-2. **Toggle analysis levels with `--analysis-level`:**
-   ```bash
-   codeanalyzer --input ./my-python-project --analysis-level 1 # Symbol table only
-   ```
-   Call graph analysis can be enabled by setting the level to `2`:
-   ```bash
-   codeanalyzer --input ./my-python-project --analysis-level 2 # Symbol table + Call graph
-   ```
-   ***Note: The `--analysis-level=2` is not yet implemented in this version.***
-
-3. **Analysis with CodeQL enabled:**
-   ```bash
-   codeanalyzer --input ./my-python-project --codeql
-   ```
-    This will perform CodeQL-based analysis in addition to the standard symbol table generation.
-
-    ***Note: Not yet fully implemented. Please refrain from using this option until further notice.***
-
-4. **Eager analysis with custom cache directory:**
-   ```bash
-   codeanalyzer --input ./my-python-project --eager --cache-dir /path/to/custom-cache
-   ```
-    This will rebuild the analysis cache at every run and store it in `/path/to/custom-cache/.codeanalyzer`. The cache will be cleared by default after analysis unless you specify `--keep-cache`.
-
-    If you provide --cache-dir, the cache will be stored in that directory. If not specified, it defaults to `.codeanalyzer` in the current working directory (`$PWD`).
-
-5. **Quiet mode (minimal output):**
-   ```bash
-   codeanalyzer --input /path/to/my-python-project --quiet
-   ```
-
-### Output
-
-By default, analysis results are printed to stdout in JSON format. When using the `--output` option, results are saved to `analysis.json` in the specified directory.
-
-## Development
-
-This project uses [uv](https://docs.astral.sh/uv/) for dependency management during development.
-
-### Development Setup
-
-1. Install [uv](https://docs.astral.sh/uv/getting-started/installation/)
-
-2. Clone the repository:
-   ```bash
-   git clone https://github.com/codellm-devkit/codeanalyzer-python
-   cd codeanalyzer-python
-   ```
-
-3. Install dependencies using uv:
-   ```bash
-   uv sync --all-groups
-   ```
-   This will install all dependencies including development and test dependencies.
-
-### Running from Source
-
-When developing, you can run the tool directly from source:
-
-```bash
-uv run codeanalyzer --input /path/to/python/project
-```
-
-### Running Tests
-
-```bash
-uv run pytest --pspec -s
-```
-
-### Development Dependencies
-
-The project includes additional dependency groups for development:
-
-- **test**: pytest and related testing tools
-- **dev**: development tools like ipdb
-
-Install all groups with:
-```bash
-uv sync --all-groups
-```