codeanalyzer-python 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

codeanalyzer/__main__.py

@@ -1,12 +1,12 @@
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Optional, Annotated
 
 import typer
 
 from codeanalyzer.core import Codeanalyzer
 from codeanalyzer.utils import _set_log_level, logger
 from codeanalyzer.config import OutputFormat
-
+from codeanalyzer.schema import model_dump_json
 
 def main(
     input: Annotated[
@@ -32,6 +32,12 @@ def main(
     using_codeql: Annotated[
         bool, typer.Option("--codeql/--no-codeql", help="Enable CodeQL-based analysis.")
     ] = False,
+    using_ray: Annotated[
+        bool,
+        typer.Option(
+            "--ray/--no-ray", help="Enable Ray for distributed analysis."
+        ),
+    ] = False,
     rebuild_analysis: Annotated[
         bool,
         typer.Option(
@@ -39,18 +45,32 @@ def main(
             help="Enable eager or lazy analysis. Defaults to lazy.",
         ),
     ] = False,
+    skip_tests: Annotated[
+        bool,
+        typer.Option(
+            "--skip-tests/--include-tests",
+            help="Skip test files in analysis.",
+        ),
+    ] = True,
+    file_name: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--file-name",
+            help="Analyze only the specified file (relative to input directory).",
+        ),
+    ] = None,
     cache_dir: Annotated[
         Optional[Path],
         typer.Option(
             "-c",
             "--cache-dir",
-            help="Directory to store analysis cache.",
+            help="Directory to store analysis cache. Defaults to '.codeanalyzer' in the input directory.",
         ),
     ] = None,
     clear_cache: Annotated[
         bool,
-        typer.Option("--clear-cache/--keep-cache", help="Clear cache after analysis."),
-    ] = True,
+        typer.Option("--clear-cache/--keep-cache", help="Clear cache after analysis. By default, cache is retained."),
+    ] = False,
     verbosity: Annotated[
         int, typer.Option("-v", count=True, help="Increase verbosity: -v, -vv, -vvv")
     ] = 0,
@@ -62,21 +82,28 @@ def main(
         logger.error(f"Input path '{input}' does not exist.")
         raise typer.Exit(code=1)
 
+    # Validate file_name if provided
+    if file_name is not None:
+        full_file_path = input / file_name
+        if not full_file_path.exists():
+            logger.error(f"Specified file '{file_name}' does not exist in '{input}'.")
+            raise typer.Exit(code=1)
+        if not full_file_path.is_file():
+            logger.error(f"Specified path '{file_name}' is not a file.")
+            raise typer.Exit(code=1)
+        if not str(file_name).endswith('.py'):
+            logger.error(f"Specified file '{file_name}' is not a Python file (.py).")
+            raise typer.Exit(code=1)
+
     with Codeanalyzer(
-        input, analysis_level, using_codeql, rebuild_analysis, cache_dir, clear_cache
+        input, analysis_level, skip_tests, using_codeql, rebuild_analysis, cache_dir, clear_cache, using_ray, file_name
     ) as analyzer:
         artifacts = analyzer.analyze()
 
         # Handle output based on format
         if output is None:
             # Output to stdout (only for JSON)
-            if format == OutputFormat.JSON:
-                print(artifacts.model_dump_json(separators=(",", ":")))
-            else:
-                logger.error(
-                    f"Format '{format.value}' requires an output directory (use -o/--output)"
-                )
-                raise typer.Exit(code=1)
+            print(model_dump_json(artifacts, separators=(",", ":")))
         else:
             # Output to file
             output.mkdir(parents=True, exist_ok=True)
@@ -87,8 +114,8 @@ 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)
+        # Use Pydantic's model_dump_json() for compact output
+        json_str = model_dump_json(artifacts, indent=None)
         with output_file.open("w") as f:
             f.write(json_str)
         logger.info(f"Analysis saved to {output_file}")

codeanalyzer/core.py

@@ -4,13 +4,39 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union, List
 
-from codeanalyzer.schema.py_schema import PyApplication, PyModule
+import ray
+from codeanalyzer.utils import logger
+from codeanalyzer.schema import PyApplication, PyModule, model_dump_json, model_validate_json
 from codeanalyzer.semantic_analysis.codeql import CodeQLLoader
 from codeanalyzer.semantic_analysis.codeql.codeql_exceptions import CodeQLExceptions
+from codeanalyzer.syntactic_analysis.exceptions import SymbolTableBuilderRayError
 from codeanalyzer.syntactic_analysis.symbol_table_builder import SymbolTableBuilder
-from codeanalyzer.utils import logger
+from codeanalyzer.utils import ProgressBar
+
+@ray.remote
+def _process_file_with_ray(py_file: Union[Path, str], project_dir: Union[Path, str], virtualenv: Union[Path, str, None]) -> Dict[str, PyModule]:
+    """Processes files in the project directory using Ray for distributed processing.
+    
+    Args:
+        py_file (Union[Path, str]): Path to the Python file to process.
+        project_dir (Union[Path, str]): Path to the project directory.
+        virtualenv (Union[Path, str, None]): Path to the virtual environment directory.
+    Returns:
+        Dict[str, PyModule]: A dictionary mapping file paths to PyModule objects.
+    """
+    from rich.console import Console
+    console = Console()
+    module_map: Dict[str, PyModule] = {}
+    try:
+        py_file = Path(py_file)
+        symbol_table_builder = SymbolTableBuilder(project_dir, virtualenv)
+        module_map[str(py_file)] = symbol_table_builder.build_pymodule_from_file(py_file)
+    except Exception as e:
+        console.log(f"❌ Failed to process {py_file}: {e}")
+        raise SymbolTableBuilderRayError(f"Ray processing error for {py_file}: {e}")
+    return module_map
 
 
 class Codeanalyzer:
@@ -28,14 +54,18 @@ class Codeanalyzer:
     def __init__(
         self,
         project_dir: Union[str, Path],
-        analysis_depth: int = 1,
-        using_codeql: bool = False,
-        rebuild_analysis: bool = False,
-        cache_dir: Optional[Path] = None,
-        clear_cache: bool = True,
+        analysis_depth: int,
+        skip_tests: bool,
+        using_codeql: bool,
+        rebuild_analysis: bool,
+        cache_dir: Optional[Path],
+        clear_cache: bool,
+        using_ray: bool,
+        file_name: Optional[Path] = None,
     ) -> None:
         self.analysis_depth = analysis_depth
         self.project_dir = Path(project_dir).resolve()
+        self.skip_tests = skip_tests
         self.using_codeql = using_codeql
         self.rebuild_analysis = rebuild_analysis
         self.cache_dir = (
@@ -45,10 +75,12 @@ class Codeanalyzer:
         self.db_path: Optional[Path] = None
         self.codeql_bin: Optional[Path] = None
         self.virtualenv: Optional[Path] = None
+        self.using_ray: bool = using_ray
+        self.file_name: Optional[Path] = file_name
 
     @staticmethod
     def _cmd_exec_helper(
-        cmd: list[str],
+        cmd: List[str],
         cwd: Optional[Path] = None,
         capture_output: bool = True,
         check: bool = True,
@@ -126,7 +158,8 @@ class Codeanalyzer:
         # We're inside a virtual environment; need to find the base interpreter
 
         # First, check if user explicitly set SYSTEM_PYTHON
-        if system_python := os.getenv("SYSTEM_PYTHON"):
+        system_python = os.getenv("SYSTEM_PYTHON")
+        if system_python:
             system_python_path = Path(system_python)
             if system_python_path.exists() and system_python_path.is_file():
                 return system_python_path
@@ -142,14 +175,16 @@ class Codeanalyzer:
 
         # Use shutil.which to find python3 and python in PATH
         for python_name in ["python3", "python"]:
-            if python_path := shutil.which(python_name):
+            python_path = shutil.which(python_name)
+            if python_path:
                 candidate = Path(python_path)
                 # Skip if this is the current virtual environment's python
                 if not str(candidate).startswith(sys.prefix):
                     python_candidates.append(candidate)
 
         # Check pyenv installation
-        if pyenv_root := os.getenv("PYENV_ROOT"):
+        pyenv_root = os.getenv("PYENV_ROOT")
+        if pyenv_root:
             pyenv_python = Path(pyenv_root) / "shims" / "python"
             if pyenv_python.exists():
                 python_candidates.append(pyenv_python)
@@ -160,15 +195,17 @@ class Codeanalyzer:
             python_candidates.append(home_pyenv)
 
         # Check conda base environment
-        if conda_prefix := os.getenv(
-            "CONDA_PREFIX_1"
-        ):  # Original conda env before activation
-            conda_python = Path(conda_prefix) / "bin" / "python"
+        conda_base = os.getenv("CONDA_PREFIX")
+        if conda_base:
+            conda_python = Path(conda_base) / "bin" / "python"
             if conda_python.exists():
                 python_candidates.append(conda_python)
 
         # Check asdf
-        if asdf_dir := os.getenv("ASDF_DIR"):
+        asdf_dir = os.getenv("ASDF_DIR")
+        # If ASDF_DIR is set, use its shims directory
+        # Otherwise, check if asdf is installed in the default location
+        if asdf_dir:
             asdf_python = Path(asdf_dir) / "shims" / "python"
             if asdf_python.exists():
                 python_candidates.append(asdf_python)
@@ -211,14 +248,61 @@ class Codeanalyzer:
             # Find python in the virtual environment
             venv_python = venv_path / "bin" / "python"
 
-            # Install the project itself (reads pyproject.toml)
-            self._cmd_exec_helper(
-                [str(venv_python), "-m", "pip", "install", "-U", f"{self.project_dir}"],
-                cwd=self.project_dir,
-                check=True,
-            )
-            # Install the project dependencies
-            self.virtualenv = venv_path
+            # First, install dependencies from various dependency files
+            dependency_files = [
+                ("requirements.txt", ["-r"]),
+                ("requirements-dev.txt", ["-r"]),
+                ("dev-requirements.txt", ["-r"]),
+                ("test-requirements.txt", ["-r"]),
+            ]
+
+            for dep_file, pip_args in dependency_files:
+                if (self.project_dir / dep_file).exists():
+                    logger.info(f"Installing dependencies from {dep_file}")
+                    self._cmd_exec_helper(
+                        [str(venv_python), "-m", "pip", "install", "-U"] + pip_args + [str(self.project_dir / dep_file)],
+                        cwd=self.project_dir,
+                        check=True,
+                    )
+
+            # Handle Pipenv files
+            if (self.project_dir / "Pipfile").exists():
+                logger.info("Installing dependencies from Pipfile")
+                # Note: This would require pipenv to be installed
+                self._cmd_exec_helper(
+                    [str(venv_python), "-m", "pip", "install", "pipenv"],
+                    cwd=self.project_dir,
+                    check=True,
+                )
+                self._cmd_exec_helper(
+                    ["pipenv", "install", "--dev"],
+                    cwd=self.project_dir,
+                    check=True,
+                )
+
+            # Handle conda environment files
+            conda_files = ["conda.yml", "environment.yml"]
+            for conda_file in conda_files:
+                if (self.project_dir / conda_file).exists():
+                    logger.info(f"Found {conda_file} - note that conda environments should be handled outside this tool")
+                    break
+
+            # Now install the project itself in editable mode (only if package definition exists)
+            package_definition_files = [
+                "pyproject.toml",    # Modern Python packaging (PEP 518/621)
+                "setup.py",          # Traditional setuptools
+                "setup.cfg",         # Setup configuration
+            ]
+
+            if any((self.project_dir / file).exists() for file in package_definition_files):
+                logger.info("Installing project in editable mode")
+                self._cmd_exec_helper(
+                    [str(venv_python), "-m", "pip", "install", "-e", str(self.project_dir)],
+                    cwd=self.project_dir,
+                    check=True,
+                )
+            else:
+                logger.warning("No package definition files found, skipping editable installation")
 
         if self.using_codeql:
             logger.info(f"(Re-)initializing CodeQL analysis for {self.project_dir}")
@@ -280,14 +364,95 @@ class Codeanalyzer:
 
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+    def __exit__(self, *args, **kwargs) -> None:
         if self.clear_cache and self.cache_dir.exists():
             logger.info(f"Clearing cache directory: {self.cache_dir}")
             shutil.rmtree(self.cache_dir)
 
     def analyze(self) -> PyApplication:
-        """Return the path to the CodeQL database."""
-        return PyApplication.builder().symbol_table(self._build_symbol_table()).build()
+        """Analyze the project and return a PyApplication with symbol table.
+        
+        Uses caching to avoid re-analyzing unchanged files.
+        """
+        cache_file = self.cache_dir / "analysis_cache.json"
+        
+        # Try to load existing cached analysis 
+        cached_pyapplication = None
+        if not self.rebuild_analysis and cache_file.exists():
+            try:
+                cached_pyapplication = self._load_pyapplication_from_cache(cache_file)
+                logger.info("Loaded cached analysis")
+            except Exception as e:
+                logger.warning(f"Failed to load cache: {e}. Rebuilding analysis.")
+                cached_pyapplication = None
+
+        # Build symbol table from cached application if available (if no available, the build a new one)
+        symbol_table = self._build_symbol_table(cached_pyapplication.symbol_table if cached_pyapplication else {})
+
+        # Recreate pyapplication
+        app = PyApplication.builder().symbol_table(symbol_table).build()
+        
+        # Save to cache
+        self._save_analysis_cache(app, cache_file)
+        
+        return app
+
+    def _load_pyapplication_from_cache(self, cache_file: Path) -> PyApplication:
+        """Load cached analysis from file.
+        
+        Args:
+            cache_file: Path to the cache file
+            
+        Returns:
+            PyApplication: The cached application data
+        """
+        with cache_file.open('r') as f:
+            data = f.read()
+        return model_validate_json(PyApplication, data)
+    
+    def _save_analysis_cache(self, app: PyApplication, cache_file: Path) -> None:
+        """Save analysis to cache file.
+        
+        Args:
+            app: The PyApplication to cache
+            cache_file: Path to save the cache file
+        """
+        # Ensure cache directory exists
+        cache_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        with cache_file.open('w') as f:
+            f.write(model_dump_json(app, indent=2))
+
+        logger.info(f"Analysis cached to {cache_file}")
+
+    def _file_unchanged(self, file_path: Path, cached_module: PyModule) -> bool:
+        """Check if a file has changed since it was cached.
+        
+        Args:
+            file_path: Path to the file to check
+            cached_module: The cached PyModule for this file
+            
+        Returns:
+            bool: True if file is unchanged, False otherwise
+        """
+        try:
+            # Check last modified time and file size
+            if (cached_module.last_modified is not None and
+                cached_module.file_size is not None and
+                cached_module.last_modified == file_path.stat().st_mtime and
+                cached_module.file_size == file_path.stat().st_size):
+                return True
+            # Also check content hash for extra safety
+            if cached_module.content_hash is not None:
+                content_hash = hashlib.sha256(file_path.read_bytes()).hexdigest()
+                return content_hash == cached_module.content_hash
+
+            # No cached metadata mismatch, assume file changed
+            return False
+            
+        except Exception as e:
+            logger.debug(f"Error checking file {file_path}: {e}")
+            return False
 
     def _compute_checksum(self, root: Path) -> str:
         """Compute SHA256 checksum of all Python source files in a project directory. If somethings changes, the
@@ -304,11 +469,131 @@ class Codeanalyzer:
             sha256.update(py_file.read_bytes())
         return sha256.hexdigest()
 
-    def _build_symbol_table(self) -> Dict[str, PyModule]:
-        """Retrieve a symbol table of the whole project."""
-        return SymbolTableBuilder(self.project_dir, self.virtualenv).build()
+    def _build_symbol_table(self, cached_symbol_table: Optional[Dict[str, PyModule]] = None) -> Dict[str, PyModule]:
+        """Builds the symbol table for the project.
+
+        This method scans the project directory, identifies Python files,
+        and constructs a symbol table containing information about classes,
+        functions, and variables defined in those files.
+        
+        Args:
+            cached_app: Previously cached PyApplication to reuse unchanged files
+        
+        Returns:
+            Dict[str, PyModule]: A dictionary mapping file paths to PyModule objects.
+        """
+        symbol_table: Dict[str, PyModule] = {}
+        
+        # Handle single file analysis
+        if self.file_name is not None:
+            single_file = self.project_dir / self.file_name
+            logger.info(f"Analyzing single file: {single_file}")
+            
+            # Check if file is in cache and unchanged
+            file_key = str(single_file)
+            if file_key in cached_symbol_table and not self.rebuild_analysis:
+                # Compute file checksum to see if it changed
+                if self._file_unchanged(single_file, cached_symbol_table[file_key]):
+                    logger.info(f"Using cached analysis for {single_file}")
+                    symbol_table[file_key] = cached_symbol_table[file_key]
+                    return symbol_table
+            
+            # File is new or changed, analyze it
+            try:
+                symbol_table_builder = SymbolTableBuilder(self.project_dir, self.virtualenv)
+                py_module = symbol_table_builder.build_pymodule_from_file(single_file)
+                symbol_table[file_key] = py_module
+                logger.info("✅ Single file analysis complete.")
+                return symbol_table
+            except Exception as e:
+                logger.error(f"Failed to process {single_file}: {e}")
+                return symbol_table
+        
+        # Get all Python files first to show accurate progress
+        py_files = []
+        for py_file in self.project_dir.rglob("*.py"):
+            rel_path = py_file.relative_to(self.project_dir)
+            path_parts = rel_path.parts
+            filename = py_file.name
+
+            # Skip directories we don't care about
+            if (
+                "site-packages" in path_parts
+                or ".venv" in path_parts
+                or ".codeanalyzer" in path_parts
+            ):
+                continue
+
+            # Skip test files if enabled
+            if self.skip_tests and (
+                "test" in path_parts
+                or "tests" in path_parts
+                or filename.startswith("test_")
+                or filename.endswith("_test.py")
+            ):
+                continue
+
+            py_files.append(py_file)
+
+        if self.using_ray:
+            logger.info("Using Ray for distributed symbol table generation.")
+            # Separate files into cached and new/changed
+            files_to_process = []
+            for py_file in py_files:
+                file_key = str(py_file)
+                if file_key in cached_symbol_table and not self.rebuild_analysis:
+                    if self._file_unchanged(py_file, cached_symbol_table[file_key]):
+                        # Use cached version
+                        symbol_table[file_key] = cached_symbol_table[file_key]
+                        continue
+                files_to_process.append(py_file)
+            
+            # Process only new/changed files with Ray
+            if files_to_process:
+                futures = [_process_file_with_ray.remote(py_file, self.project_dir, str(self.virtualenv) if self.virtualenv else None) for py_file in files_to_process]
+                
+                with ProgressBar(len(futures), "Building symbol table (parallel)") as progress:
+                    pending = futures[:]
+                    while pending:
+                        done, pending = ray.wait(pending, num_returns=1)
+                        result = ray.get(done[0])
+                        if result:
+                            symbol_table.update(result)
+                        progress.advance()
+        else:
+            logger.info("Building symbol table serially.")
+            symbol_table_builder = SymbolTableBuilder(self.project_dir, self.virtualenv)
+            files_processed = 0
+            files_from_cache = 0
+            
+            with ProgressBar(len(py_files), "Building symbol table") as progress:
+                for py_file in py_files:
+                    file_key = str(py_file)
+                    
+                    # Check if file is cached and unchanged
+                    if file_key in cached_symbol_table and not self.rebuild_analysis:
+                        if self._file_unchanged(py_file, cached_symbol_table[file_key]):
+                            symbol_table[file_key] = cached_symbol_table[file_key]
+                            files_from_cache += 1
+                            progress.advance()
+                            continue
+                    
+                    # File is new or changed, analyze it
+                    try:
+                        py_module = symbol_table_builder.build_pymodule_from_file(py_file)
+                        symbol_table[file_key] = py_module
+                        files_processed += 1
+                    except Exception as e:
+                        logger.error(f"Failed to process {py_file}: {e}")
+                    progress.advance()
+            
+            if files_from_cache > 0:
+                logger.info(f"Reused {files_from_cache} files from cache, processed {files_processed} new/changed files")
+
+        logger.info("✅ Symbol table generation complete.")
+        return symbol_table
 
     def _get_call_graph(self) -> Dict[str, Any]:
         """Retrieve call graph from CodeQL database."""
         logger.warning("Call graph extraction not yet implemented.")
-        return {}
+        return {}

codeanalyzer/schema/__init__.py

@@ -1,3 +1,6 @@
+from importlib.metadata import version, PackageNotFoundError
+from packaging.version import parse as parse_version
+
 from .py_schema import (
     PyApplication,
     PyCallable,
@@ -21,3 +24,49 @@ __all__ = [
     "PyClassAttribute",
     "PyCallableParameter",
 ]
+
+try:
+    pydantic_version = version("pydantic")
+except PackageNotFoundError:
+    pydantic_version = "0.0.0"  # fallback or raise if appropriate
+
+PYDANTIC_V2 = parse_version(pydantic_version) >= parse_version("2.0.0")
+
+if not PYDANTIC_V2:
+    # Safe to pass localns
+    PyCallable.update_forward_refs(PyClass=PyClass)
+    PyClass.update_forward_refs(PyCallable=PyCallable)
+    PyModule.update_forward_refs(PyCallable=PyCallable, PyClass=PyClass)
+    PyApplication.update_forward_refs(
+        PyCallable=PyCallable,
+        PyClass=PyClass,
+        PyModule=PyModule
+    )
+    
+# Compatibility helpers for Pydantic v1/v2
+def model_dump_json(model, **kwargs):
+    """Compatibility helper for JSON serialization."""
+    if PYDANTIC_V2:
+        return model.model_dump_json(**kwargs)
+    else:
+        # Map Pydantic v2 parameters to v1 equivalents
+        v1_kwargs = {}
+        if 'indent' in kwargs:
+            v1_kwargs['indent'] = kwargs['indent']
+        if 'separators' in kwargs:
+            # In v1, separators is passed to dumps_kwargs
+            v1_kwargs['separators'] = kwargs['separators']
+        return model.json(**v1_kwargs)
+
+def model_validate_json(model_class, json_data):
+    """Compatibility helper for JSON deserialization."""
+    if PYDANTIC_V2:
+        return model_class.model_validate_json(json_data)
+    else:
+        return model_class.parse_raw(json_data)
+
+__all__.extend([
+    "PYDANTIC_V2",
+    "model_dump_json",
+    "model_validate_json"
+])

codeanalyzer/schema/py_schema.py

@@ -19,7 +19,7 @@
 This module defines the data models used to represent Python code structures
 for static analysis purposes.
 """
-
+from __future__ import annotations
 import inspect
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -148,7 +148,8 @@ def builder(cls):
 
             method.__name__ = f"{f}"
             method.__annotations__ = {"value": t, "return": builder_name}
-            method.__doc__ = f"Set {f} ({t.__name__})"
+            # Check if 't' has '__name__' attribute, otherwise use a fallback
+            method.__doc__ = f"Set {f} ({getattr(t, '__name__', str(t))})"
             return method
 
         namespace[f"{field}"] = make_method()
@@ -275,12 +276,16 @@ class PyCallable(BaseModel):
     code_start_line: int = -1
     accessed_symbols: List[PySymbol] = []
     call_sites: List[PyCallsite] = []
+    inner_callables: Dict[str, "PyCallable"] = {}
+    inner_classes: Dict[str, "PyClass"] = {}
     local_variables: List[PyVariableDeclaration] = []
     cyclomatic_complexity: int = 0
 
     def __hash__(self) -> int:
         """Generate a hash based on the callable's signature."""
         return hash(self.signature)
+    
+    
 
 
 @builder
@@ -328,6 +333,10 @@ class PyModule(BaseModel):
     classes: Dict[str, PyClass] = {}
     functions: Dict[str, PyCallable] = {}
     variables: List[PyVariableDeclaration] = []
+    # Metadata for caching
+    content_hash: Optional[str] = None
+    last_modified: Optional[float] = None
+    file_size: Optional[int] = None
 
 
 @builder
@@ -335,4 +344,4 @@ class PyModule(BaseModel):
 class PyApplication(BaseModel):
     """Represents a Python application."""
 
-    symbol_table: dict[Path, PyModule]
+    symbol_table: Dict[str, PyModule]

codeanalyzer/syntactic_analysis/__init__.py

@@ -0,0 +1,16 @@
+from codeanalyzer.syntactic_analysis.exceptions import (
+    SymbolTableBuilderException,
+    SymbolTableBuilderFileNotFoundError,
+    SymbolTableBuilderParsingError,
+    SymbolTableBuilderRayError,
+)
+
+from codeanalyzer.syntactic_analysis.symbol_table_builder import SymbolTableBuilder
+
+__all__ = [
+    "SymbolTableBuilder",
+    "SymbolTableBuilderException",
+    "SymbolTableBuilderFileNotFoundError",
+    "SymbolTableBuilderParsingError",
+    "SymbolTableBuilderRayError",
+]

codeanalyzer/syntactic_analysis/exceptions.py

@@ -0,0 +1,15 @@
+class SymbolTableBuilderException(Exception):
+    """Base exception for symbol table builder errors."""
+    pass
+
+class SymbolTableBuilderFileNotFoundError(SymbolTableBuilderException):
+    """Exception raised when a source file is not found."""
+    pass
+
+class SymbolTableBuilderParsingError(SymbolTableBuilderException):
+    """Exception raised when a source file cannot be parsed."""
+    pass
+
+class SymbolTableBuilderRayError(SymbolTableBuilderException):
+    """Exception raised when there is an error in Ray processing."""
+    pass

codeanalyzer/syntactic_analysis/symbol_table_builder.py

@@ -1,9 +1,10 @@
 import ast
+import hashlib
 import tokenize
 from ast import AST, ClassDef
 from io import StringIO
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 import jedi
 from jedi.api import Script
@@ -21,14 +22,12 @@ from codeanalyzer.schema.py_schema import (
     PySymbol,
     PyVariableDeclaration,
 )
-from codeanalyzer.utils import logger
-from codeanalyzer.utils.progress_bar import ProgressBar
 
 
 class SymbolTableBuilder:
     """A class for building a symbol table for a Python project."""
 
-    def __init__(self, project_dir: Path | str, virtualenv: Path | str | None) -> None:
+    def __init__(self, project_dir: Union[Path, str], virtualenv: Union[Path, str, None]) -> None:
         self.project_dir = Path(project_dir)
         if virtualenv is None:
             # If no virtual environment is provided, create a jedi project without an environment.
@@ -72,7 +71,7 @@ class SymbolTableBuilder:
             pass
         return None
 
-    def _module(self, py_file: Path) -> PyModule:
+    def build_pymodule_from_file(self, py_file: Path) -> PyModule:
         """Builds a PyModule from a Python file.
 
         Args:
@@ -83,18 +82,17 @@ class SymbolTableBuilder:
         """
         # Get the raw source code from the file
         source = py_file.read_text(encoding="utf-8")
+        
+        # Get file metadata for caching
+        stat = py_file.stat()
+        file_size = stat.st_size
+        last_modified = stat.st_mtime
+        content_hash = hashlib.sha256(source.encode('utf-8')).hexdigest()
+        
         # Create a Jedi script for the file
         script: Script = Script(path=str(py_file), project=self.jedi_project)
         module = ast.parse(source, filename=str(py_file))
-
-        classes = {}
-        functions = {}
-        for node in ast.iter_child_nodes(module):
-            if isinstance(node, ClassDef):
-                classes.update(self._add_class(node, script))
-            elif isinstance(node, ast.FunctionDef):
-                functions.update(self._callables(node, script))
-
+        
         return (
             PyModule.builder()
             .file_path(str(py_file))
@@ -102,8 +100,11 @@ class SymbolTableBuilder:
             .comments(self._pycomments(module, source))
             .imports(self._imports(module))
             .variables(self._module_variables(module, script))
-            .classes(classes)
-            .functions(functions)
+            .classes(self._add_class(module, script))
+            .functions(self._callables(module, script))
+            .content_hash(content_hash)
+            .last_modified(last_modified)
+            .file_size(file_size)
             .build()
         )
 
@@ -156,144 +157,112 @@ class SymbolTableBuilder:
 
         return imports
 
-    def _add_class(
-        self, class_node: ast.ClassDef, script: Script
-    ) -> Dict[str, PyClass]:
-        """Builds a PyClass from a class definition node.
-
-        Args:
-            class_node (ast.ClassDef): The AST node representing the class.
-            script (Script): The Jedi script object for the module.
+    def _add_class(self, node: AST, script: Script, prefix: str = "") -> Dict[str, PyClass]:
+        classes: Dict[str, PyClass] = {}
 
-        Returns:
-            Dict[str, PyClass]: Mapping of class signature to PyClass object.
-        """
-        # Try resolving full signature with Jedi
-        try:
-            definitions = script.goto(
-                line=class_node.lineno, column=class_node.col_offset
-            )
-            signature = next(
-                (d.full_name for d in definitions if d.type == "class"),
-                f"{script.path.__str__().replace('/', '.').replace('.py', '')}.{class_node.name}",
-            )
-        except Exception:
-            signature = (
-                f"{script.path.__str__().replace('/', '.').replace('.py', '')}.{class_node.name}",
-            )
+        for child in ast.iter_child_nodes(node):
+            if not isinstance(child, ast.ClassDef):
+                continue
 
-        code: str = ast.unparse(class_node).strip()
+            class_name = child.name
+            start_line = child.lineno
+            end_line = getattr(child, "end_lineno", start_line + len(child.body))
+            code = ast.unparse(child).strip()
 
-        py_class = (
-            PyClass.builder()
-            .name(class_node.name)
-            .signature(signature)
-            .start_line(class_node.lineno)
-            .end_line(
-                getattr(
-                    class_node, "end_lineno", class_node.lineno + len(class_node.body)
-                )
-            )
-            .comments(self._pycomments(class_node, code))
-            .code(code)
-            .base_classes(
-                [
+            # Try resolving full signature with Jedi
+            if prefix:
+                signature = f"{prefix}.{class_name}"
+            else:
+                try:
+                    definitions = script.goto(line=start_line, column=child.col_offset)
+                    signature = next(
+                        (d.full_name for d in definitions if d.type == "class"),
+                        f"{Path(script.path).relative_to(self.project_dir).__str__().replace('/', '.').replace('.py', '')}.{class_name}"
+                    )
+                except Exception:
+                    signature = f"{Path(script.path).relative_to(self.project_dir).__str__().replace('/', '.').replace('.py', '')}.{class_name}"
+            py_class = (
+                PyClass.builder()
+                .name(class_name)
+                .signature(signature)
+                .start_line(start_line)
+                .end_line(end_line)
+                .code(code)
+                .comments(self._pycomments(child, code))
+                .base_classes([
                     ast.unparse(base)
-                    for base in class_node.bases
+                    for base in child.bases
                     if isinstance(base, ast.expr)
-                ]
-            )
-            .methods(self._callables(class_node, script))
-            .attributes(self._class_attributes(class_node, script))
-            .inner_classes(
-                {
-                    k: v
-                    for child in class_node.body
-                    if isinstance(child, ast.ClassDef)
-                    for k, v in self._add_class(child, script).items()
-                }
+                ])
+                .methods(self._callables(child, script, prefix=signature))  # Pass class signature as prefix
+                .attributes(self._class_attributes(child, script))
+                .inner_classes(self._add_class(child, script, prefix=signature))  # Pass class signature as prefix
+                .build()
             )
-            .build()
-        )
 
-        return {signature: py_class}
+            classes[signature] = py_class
 
-    def _callables(self, node: AST, script: Script) -> Dict[str, PyCallable]:
-        """
-        Builds PyCallable objects from any AST node that may contain functions.
+        return classes
 
-        Args:
-            node (AST): The AST node to process (e.g., Module, ClassDef, FunctionDef).
-            script (Script): The Jedi script object for the module.
 
-        Returns:
-            Dict[str, PyCallable]: A dictionary mapping function/method names to PyCallable objects.
-        """
+    def _callables(self, node: AST, script: Script, prefix: str = "") -> Dict[str, PyCallable]:
         callables: Dict[str, PyCallable] = {}
-        module_path: str = script.path or "<unknown_module>"
-        module_name: str = Path(module_path).stem if module_path else "<unknown>"
-
-        def visit(n: AST, class_prefix: str = ""):
-            for child in ast.iter_child_nodes(n):
-                if isinstance(child, ast.FunctionDef):
-                    method_name = child.name
-                    start_line = child.lineno
-                    end_line = getattr(
-                        child, "end_lineno", start_line + len(child.body)
-                    )
-                    code_start_line = child.body[0].lineno if child.body else start_line
-                    code: str = ast.unparse(child).strip()
-                    decorators = [ast.unparse(d) for d in child.decorator_list]
 
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                method_name = child.name  # Keep the actual method name unchanged
+                start_line = child.lineno
+                end_line = getattr(child, "end_lineno", start_line + len(child.body))
+                code = ast.unparse(child).strip()
+                decorators = [ast.unparse(d) for d in child.decorator_list]
+                
+                if prefix:
+                    # We're in a nested context - build signature with prefix
+                    signature = f"{prefix}.{method_name}"
+                else:
+                    # Top-level function - try Jedi first, fall back to relative path-based
                     try:
-                        definitions = script.goto(
-                            line=start_line, column=child.col_offset
+                        definitions = script.goto(line=start_line, column=child.col_offset)
+                        signature = next(
+                            (d.full_name for d in definitions if d.type == "function"),
+                            None
                         )
                     except Exception:
-                        definitions = []
-
-                    signature = next(
-                        (d.full_name for d in definitions if d.type == "function"),
-                        f"{module_name}.{class_prefix}{method_name}",
+                        signature = None
+                    
+                    # If Jedi didn't provide a signature, build one relative to project_dir
+                    if not signature:
+                        relative_path = Path(script.path).relative_to(self.project_dir)
+                        signature = f"{str(relative_path).replace('/', '.').replace('.py', '')}.{method_name}"
+                py_callable = (
+                    PyCallable.builder()
+                    .name(method_name)  # Use the actual method name, not the full signature
+                    .path(str(script.path))
+                    .signature(signature)  # Use the full signature here
+                    .decorators(decorators)
+                    .code(code)
+                    .start_line(start_line)
+                    .end_line(end_line)
+                    .code_start_line(child.body[0].lineno if child.body else start_line)
+                    .accessed_symbols(self._accessed_symbols(child, script))
+                    .call_sites(self._call_sites(child, script))
+                    .local_variables(self._local_variables(child, script))
+                    .cyclomatic_complexity(self._cyclomatic_complexity(child))
+                    .parameters(self._callable_parameters(child, script))
+                    .return_type(
+                        ast.unparse(child.returns)
+                        if child.returns else self._infer_type(script, child.lineno, child.col_offset)
                     )
+                    .comments(self._pycomments(child, code))
+                    .inner_callables(self._callables(child, script, signature))  # Pass current signature as prefix
+                    .inner_classes(self._add_class(child, script, signature))    # Pass current signature as prefix
+                    .build()
+                )
 
-                    callables[method_name] = (
-                        PyCallable.builder()
-                        .name(method_name)
-                        .path(script.path.__str__())
-                        .signature(signature)
-                        .decorators(decorators)
-                        .code(code)
-                        .start_line(start_line)
-                        .end_line(end_line)
-                        .code_start_line(code_start_line)
-                        .accessed_symbols(self._accessed_symbols(child, script))
-                        .call_sites(self._call_sites(child, script))
-                        .local_variables(self._local_variables(child, script))
-                        .cyclomatic_complexity(self._cyclomatic_complexity(child))
-                        .parameters(self._callable_parameters(child, script))
-                        .return_type(
-                            ast.unparse(child.returns)
-                            if child.returns
-                            else self._infer_type(
-                                script, child.lineno, child.col_offset
-                            )
-                        )
-                        .comments(self._pycomments(child, code))
-                        .build()
-                    )
-
-                    visit(child, class_prefix + method_name + ".")
-
-                elif isinstance(child, ast.ClassDef):
-                    visit(child, class_prefix + child.name + ".")
-
-                elif hasattr(child, "body"):
-                    visit(child, class_prefix)
+                callables[method_name] = py_callable  # Key by method name, not full signature
 
-        visit(node)
         return callables
-
+    
     def _pycomments(self, node: ast.AST, source: str) -> List[PyComment]:
         """
         Extracts all PyComment instances (docstring and # comments) from within a specific AST node's body.
@@ -868,35 +837,3 @@ class SymbolTableBuilder:
             .col_offset(col_offset)
             .build()
         )
-
-    def build(self) -> Dict[str, PyModule]:
-        """Builds the symbol table for the project.
-
-        This method scans the project directory, identifies Python files,
-        and constructs a symbol table containing information about classes,
-        functions, and variables defined in those files.
-        """
-        symbol_table: Dict[str, PyModule] = {}
-        # Get all Python files first to show accurate progress
-        py_files = [
-            py_file
-            for py_file in self.project_dir.rglob("*.py")
-            if "site-packages"
-            not in py_file.resolve().__str__()  # exclude site-packages
-            and ".venv"
-            not in py_file.resolve().__str__()  # exclude virtual environments
-            and ".codeanalyzer"
-            not in py_file.resolve().__str__()  # exclude internal cache directories
-        ]
-
-        with ProgressBar(len(py_files), "Building symbol table") as progress:
-            for py_file in py_files:
-                try:
-                    py_module = self._module(py_file)
-                    symbol_table[str(py_file)] = py_module
-                except Exception as e:
-                    logger.error(f"Failed to process {py_file}: {e}")
-                progress.advance()
-            progress.finish("✅ Symbol table generation complete.")
-
-        return symbol_table

{codeanalyzer_python-0.1.9.dist-info → codeanalyzer_python-0.1.11.dist-info}/METADATA

@@ -1,20 +1,34 @@
 Metadata-Version: 2.4
 Name: codeanalyzer-python
-Version: 0.1.9
+Version: 0.1.11
 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.10
-Requires-Dist: jedi>=0.19.2
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: msgpack>=1.1.1
-Requires-Dist: networkx>=3.4.2
-Requires-Dist: pandas>=2.3.1
-Requires-Dist: pydantic>=2.11.7
-Requires-Dist: requests>=2.32.4
-Requires-Dist: rich>=14.0.0
-Requires-Dist: typer>=0.16.0
+Requires-Python: >=3.9
+Requires-Dist: jedi<0.20.0,>=0.18.0; python_version < '3.11'
+Requires-Dist: jedi<=0.19.2; python_version >= '3.11'
+Requires-Dist: msgpack<1.0.7,>=1.0.0; python_version < '3.11'
+Requires-Dist: msgpack<2.0.0,>=1.0.7; python_version >= '3.11'
+Requires-Dist: networkx<3.2.0,>=2.6.0; python_version < '3.11'
+Requires-Dist: networkx<4.0.0,>=3.0.0; python_version >= '3.11'
+Requires-Dist: numpy<1.24.0,>=1.21.0; python_version < '3.11'
+Requires-Dist: numpy<2.0.0,>=1.24.0; python_version >= '3.11' and python_version < '3.12'
+Requires-Dist: numpy<2.0.0,>=1.26.0; python_version >= '3.12'
+Requires-Dist: packaging>=25.0
+Requires-Dist: pandas<2.0.0,>=1.3.0; python_version < '3.11'
+Requires-Dist: pandas<3.0.0,>=2.0.0; python_version >= '3.11'
+Requires-Dist: pydantic<2.0.0,>=1.8.0; python_version < '3.11'
+Requires-Dist: pydantic<3.0.0,>=2.0.0; python_version >= '3.11'
+Requires-Dist: ray<3.0.0,>=2.10.0; python_version >= '3.11'
+Requires-Dist: ray==2.0.0; python_version < '3.11'
+Requires-Dist: requests<3.0.0,>=2.20.0; python_version >= '3.11'
+Requires-Dist: rich<14.0.0,>=12.6.0; python_version < '3.11'
+Requires-Dist: rich<15.0.0,>=14.0.0; python_version >= '3.11'
+Requires-Dist: typer<1.0.0,>=0.9.0; python_version < '3.11'
+Requires-Dist: typer<2.0.0,>=0.9.0; python_version >= '3.11'
+Requires-Dist: typing-extensions<5.0.0,>=4.0.0; python_version < '3.11'
+Requires-Dist: typing-extensions<6.0.0,>=4.5.0; python_version >= '3.11'
 Description-Content-Type: text/markdown
 
 ![logo](https://github.com/codellm-devkit/codeanalyzer-python/blob/main/docs/assets/logo.png?raw=true)
@@ -95,17 +109,18 @@ To view the available options and commands, run `codeanalyzer --help`. You shoul
  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.                                      │
-╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ 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
@@ -123,7 +138,14 @@ To view the available options and commands, run `codeanalyzer --help`. You shoul
 
    Now, you can find the analysis results in `analysis.json` in the specified directory.
 
-2. **Toggle analysis levels with `--analysis-level`:**
+2. **Change output format to msgpack:**
+   ```bash
+   codeanalyzer --input ./my-python-project --output /path/to/analysis-results --format msgpack
+   ```
+
+   This will save the analysis results in `analysis.msgpack` in the specified directory.
+
+3. **Toggle analysis levels with `--analysis-level`:**
    ```bash
    codeanalyzer --input ./my-python-project --analysis-level 1 # Symbol table only
    ```
@@ -133,7 +155,7 @@ To view the available options and commands, run `codeanalyzer --help`. You shoul
    ```
    ***Note: The `--analysis-level=2` is not yet implemented in this version.***
 
-3. **Analysis with CodeQL enabled:**
+4. **Analysis with CodeQL enabled:**
    ```bash
    codeanalyzer --input ./my-python-project --codeql
    ```
@@ -141,7 +163,7 @@ To view the available options and commands, run `codeanalyzer --help`. You shoul
 
     ***Note: Not yet fully implemented. Please refrain from using this option until further notice.***
 
-4. **Eager analysis with custom cache directory:**
+5. **Eager analysis with custom cache directory:**
    ```bash
    codeanalyzer --input ./my-python-project --eager --cache-dir /path/to/custom-cache
    ```
@@ -149,14 +171,14 @@ To view the available options and commands, run `codeanalyzer --help`. You shoul
 
     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):**
+6. **Quiet mode (minimal output):**
    ```bash
    codeanalyzer --input /path/to/my-python-project --quiet
    ```
 
-### Output
+## 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.
+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. If you use the `--format=msgpack` option, the results will be saved in `analysis.msgpack`, which is a binary format that can be more efficient for storage and transmission.
 
 ## Development
 

{codeanalyzer_python-0.1.9.dist-info → codeanalyzer_python-0.1.11.dist-info}/RECORD

@@ -1,13 +1,13 @@
 codeanalyzer/__init__.py,sha256=BZ3Kuwl-F_F-8H8cepLnVJ4Ku4NNUjjqg0Y6ujPQSsI,108
-codeanalyzer/__main__.py,sha256=CHSa6A-AT5XtZ2GJvEEdjz8emr7Mr3xP4qG5xxRWX7k,3863
-codeanalyzer/core.py,sha256=BVlfCaMqIRfaUkOk9_5XrnuvzHZ0WBtAkjRj3yOMHRI,12431
+codeanalyzer/__main__.py,sha256=e-AMzR5uR1IsUKhsfk17_qPJkwORRqe9tBxCXwwlxBY,4922
+codeanalyzer/core.py,sha256=swFc-6ICs_rijj7P0bbJv3um2Gr-R8_roGK0P3qo1xc,24979
 codeanalyzer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/config/__init__.py,sha256=9XBxAn1oWGRuhg3bEBUuVGs3hFNXEAKrr-Ce7tq9a2k,61
 codeanalyzer/config/config.py,sha256=ZiKzc5uEUCIvih58-6BDtLLI1hPij41wGQjBcj9KNQM,188
 codeanalyzer/jedi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/jedi/jedi.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codeanalyzer/schema/__init__.py,sha256=bIwfGFvgqtNZ0mCAvDXSo9WVJHqhm15iZc7YOuWYSZ0,390
-codeanalyzer/schema/py_schema.py,sha256=YFd0EtJkTOiOruaVkO_ibbzTktSPOvKDvsxqcI3n9J8,10471
+codeanalyzer/schema/__init__.py,sha256=HB7y4y-49dkEo-H9GREam1_9Cr1N-GF6MYwx9yoU878,1978
+codeanalyzer/schema/py_schema.py,sha256=04K19tDtmg2tPXjwu_8BcmVpenk1ibVwNv6bHWZHOLY,10851
 codeanalyzer/semantic_analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/semantic_analysis/codeql/__init__.py,sha256=ODMkdGvs3ebJdfIZle8T4VcHoCBhH_ZehWuWFpNh3NI,1022
 codeanalyzer/semantic_analysis/codeql/codeql_analysis.py,sha256=-mVTm2JdQlfmV_9T4xLgjxwROKS83aP7lJAmQHh37xY,5312
@@ -15,14 +15,15 @@ codeanalyzer/semantic_analysis/codeql/codeql_exceptions.py,sha256=PnJOasW9rP68SE
 codeanalyzer/semantic_analysis/codeql/codeql_loader.py,sha256=o0BW-6yHkN6kLG66rOYQQ_ToQUn5Ivl9h9ZdBM3_E_Q,2288
 codeanalyzer/semantic_analysis/codeql/codeql_query_runner.py,sha256=QJtID1YZkO6Wyns_qTJFqOSiV238ArLXwgLv105B27E,6520
 codeanalyzer/semantic_analysis/wala/__init__.py,sha256=JSDvkrpJ2U90Ikex34EluSHmoGutlmRhV2xvInt6tB8,743
-codeanalyzer/syntactic_analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codeanalyzer/syntactic_analysis/symbol_table_builder.py,sha256=kwmJiJV01olKcKPQKrZ8Mp3CKOMPdrM7dvb7pB6v3hg,36194
+codeanalyzer/syntactic_analysis/__init__.py,sha256=EUQkJEh6wHjWx2qTTKbTbUgwSbfKeNieKHNy7RknVXA,476
+codeanalyzer/syntactic_analysis/exceptions.py,sha256=whs_n0vIu655Jkk1a7iOoXY6iIca4pZqJnU40V9Ejaw,537
+codeanalyzer/syntactic_analysis/symbol_table_builder.py,sha256=0FE_ZdlyP77P1B70QXhPKO4AEPm2KvA3-llaAjIrOJU,34639
 codeanalyzer/utils/__init__.py,sha256=hC6VWdR5rerSqBxzu9KQHTASWqwrrYJv-CMDwrTlzkc,137
 codeanalyzer/utils/logging.py,sha256=0vTkGSl5EZN8yhhWa_5Mrn1n_twRCSW53rNwjzQ9RbI,601
 codeanalyzer/utils/progress_bar.py,sha256=ZHJzGiCo5q4dyXq4CtsrJeq9Ip7sD84T3yZjNX7TBys,2443
-codeanalyzer_python-0.1.9.dist-info/METADATA,sha256=HpZwqxr1Q_hz8sXnXFNMiOWhyHafGZ-pNK01MqpKHjs,14460
-codeanalyzer_python-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-codeanalyzer_python-0.1.9.dist-info/entry_points.txt,sha256=eUrB7Jq5Oav6RblMX_RYfVLSw_h15NbzC3fNSnGsPuM,59
-codeanalyzer_python-0.1.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-codeanalyzer_python-0.1.9.dist-info/licenses/NOTICE,sha256=YU0Z9NDWqKY-2jfFcbxeZ6fbnzz0oZeKmnUcO8a-bcQ,901
-codeanalyzer_python-0.1.9.dist-info/RECORD,,
+codeanalyzer_python-0.1.11.dist-info/METADATA,sha256=yqQiVgSsG1k262sigcRo51BScmuVQywLOtL9rEX5ATI,16283
+codeanalyzer_python-0.1.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+codeanalyzer_python-0.1.11.dist-info/entry_points.txt,sha256=eUrB7Jq5Oav6RblMX_RYfVLSw_h15NbzC3fNSnGsPuM,59
+codeanalyzer_python-0.1.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+codeanalyzer_python-0.1.11.dist-info/licenses/NOTICE,sha256=YU0Z9NDWqKY-2jfFcbxeZ6fbnzz0oZeKmnUcO8a-bcQ,901
+codeanalyzer_python-0.1.11.dist-info/RECORD,,