codeanalyzer-python 0.1.10__tar.gz → 0.1.12__tar.gz

{codeanalyzer_python-0.1.10 → codeanalyzer_python-0.1.12}/PKG-INFO

@@ -1,22 +1,34 @@
 Metadata-Version: 2.4
 Name: codeanalyzer-python
-Version: 0.1.10
+Version: 0.1.12
 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.9
-Requires-Dist: jedi<0.20.0,>=0.18.0
-Requires-Dist: msgpack<1.0.7,>=1.0.0
-Requires-Dist: networkx<3.2.0,>=2.6.0
-Requires-Dist: numpy<1.24.0,>=1.21.0
-Requires-Dist: pandas<2.0.0,>=1.3.0
-Requires-Dist: pydantic<2.0.0,>=1.8.0
-Requires-Dist: ray<3.0.0,>=2.0.0
-Requires-Dist: requests<3.0.0,>=2.20.0
-Requires-Dist: rich<14.0.0,>=12.6.0
-Requires-Dist: typer<1.0.0,>=0.9.0
-Requires-Dist: typing-extensions>=4.0.0
+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)

codeanalyzer_python-0.1.12/codeanalyzer/__main__.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+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
+from codeanalyzer.options import AnalysisOptions
+
+def main(
+    input: Annotated[Path, typer.Option("-i", "--input", help="Path to the project root directory.")],
+    output: Optional[Path] = typer.Option(None, "-o", "--output"),
+    format: OutputFormat = typer.Option(OutputFormat.JSON, "-f", "--format"),
+    analysis_level: int = typer.Option(1, "-a", "--analysis-level"),
+    using_codeql: bool = typer.Option(False, "--codeql/--no-codeql"),
+    using_ray: bool = typer.Option(False, "--ray/--no-ray"),
+    rebuild_analysis: bool = typer.Option(False, "--eager/--lazy"),
+    skip_tests: bool = typer.Option(True, "--skip-tests/--include-tests"),
+    file_name: Optional[Path] = typer.Option(None, "--file-name"),
+    cache_dir: Optional[Path] = typer.Option(None, "-c", "--cache-dir"),
+    clear_cache: bool = typer.Option(False, "--clear-cache/--keep-cache"),
+    verbosity: int = typer.Option(0, "-v", count=True),
+):
+    options = AnalysisOptions(
+        input=input,
+        output=output,
+        format=format,
+        analysis_level=analysis_level,
+        using_codeql=using_codeql,
+        using_ray=using_ray,
+        rebuild_analysis=rebuild_analysis,
+        skip_tests=skip_tests,
+        file_name=file_name,
+        cache_dir=cache_dir,
+        clear_cache=clear_cache,
+        verbosity=verbosity,
+    )
+
+    _set_log_level(options.verbosity)
+    if not options.input.exists():
+        logger.error(f"Input path '{options.input}' does not exist.")
+        raise typer.Exit(code=1)
+
+    if options.file_name is not None:
+        full_file_path = options.input / options.file_name
+        if not full_file_path.exists():
+            logger.error(f"Specified file '{options.file_name}' does not exist in '{options.input}'.")
+            raise typer.Exit(code=1)
+        if not full_file_path.is_file():
+            logger.error(f"Specified path '{options.file_name}' is not a file.")
+            raise typer.Exit(code=1)
+        if not str(options.file_name).endswith('.py'):
+            logger.error(f"Specified file '{options.file_name}' is not a Python file (.py).")
+            raise typer.Exit(code=1)
+
+    with Codeanalyzer(options) as analyzer:
+        artifacts = analyzer.analyze()
+
+        if options.output is None:
+            print(model_dump_json(artifacts, separators=(",", ":")))
+        else:
+            options.output.mkdir(parents=True, exist_ok=True)
+            _write_output(artifacts, options.output, options.format)
+
+
+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 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}")
+
+    elif format == OutputFormat.MSGPACK:
+        output_file = output_dir / "analysis.msgpack"
+        msgpack_data = artifacts.to_msgpack_bytes()
+        with output_file.open("wb") as f:
+            f.write(msgpack_data)
+        logger.info(f"Analysis saved to {output_file}")
+        logger.info(
+            f"Compression ratio: {artifacts.get_compression_ratio():.1%} of JSON size"
+        )
+
+app = typer.Typer(
+    callback=main,
+    name="codeanalyzer",
+    help="Static Analysis on Python source code using Jedi, CodeQL and Tree sitter.",
+    invoke_without_command=True,
+    no_args_is_help=True,
+    add_completion=False,
+    rich_markup_mode="rich",
+    pretty_exceptions_show_locals=False,
+)
+
+if __name__ == "__main__":
+    app()

{codeanalyzer_python-0.1.10 → codeanalyzer_python-0.1.12}/codeanalyzer/core.py

@@ -8,12 +8,13 @@ from typing import Any, Dict, Optional, Union, List
 
 import ray
 from codeanalyzer.utils import logger
-from codeanalyzer.schema import PyApplication, PyModule
+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 ProgressBar
+from codeanalyzer.options import AnalysisOptions
 
 @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]:
@@ -43,40 +44,25 @@ class Codeanalyzer:
     """Core functionality for CodeQL analysis.
 
     Args:
-        project_dir (Union[str, Path]): The root directory of the project to analyze.
-        virtualenv (Optional[Path]): Path to the virtual environment directory.
-        using_codeql (bool): Whether to use CodeQL for analysis.
-        rebuild_analysis (bool): Whether to force rebuild the database.
-        clear_cache (bool): Whether to delete the cached directory after analysis.
-        analysis_depth (int): Depth of analysis (reserved for future use).
+        options (AnalysisOptions): Analysis configuration options containing all necessary parameters.
     """
 
-    def __init__(
-        self,
-        project_dir: Union[str, Path],
-        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
+    def __init__(self, options: AnalysisOptions) -> None:
+        self.options = options
+        self.analysis_depth = options.analysis_level
+        self.project_dir = Path(options.input).resolve()
+        self.skip_tests = options.skip_tests
+        self.using_codeql = options.using_codeql
+        self.rebuild_analysis = options.rebuild_analysis
         self.cache_dir = (
-            cache_dir.resolve() if cache_dir is not None else self.project_dir
+            options.cache_dir.resolve() if options.cache_dir is not None else self.project_dir
         ) / ".codeanalyzer"
-        self.clear_cache = clear_cache
+        self.clear_cache = options.clear_cache
         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
+        self.using_ray: bool = options.using_ray
+        self.file_name: Optional[Path] = options.file_name
 
     @staticmethod
     def _cmd_exec_helper(
@@ -408,7 +394,7 @@ class Codeanalyzer:
         """
         with cache_file.open('r') as f:
             data = f.read()
-        return PyApplication.parse_raw(data)
+        return model_validate_json(PyApplication, data)
     
     def _save_analysis_cache(self, app: PyApplication, cache_file: Path) -> None:
         """Save analysis to cache file.
@@ -421,8 +407,8 @@ class Codeanalyzer:
         cache_file.parent.mkdir(parents=True, exist_ok=True)
         
         with cache_file.open('w') as f:
-            f.write(app.json(indent=2))
-        
+            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:

codeanalyzer_python-0.1.12/codeanalyzer/options/__init__.py

@@ -0,0 +1,3 @@
+from .options import AnalysisOptions
+
+__all__ = ["AnalysisOptions"]

codeanalyzer_python-0.1.12/codeanalyzer/options/options.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+from enum import Enum
+
+
+class OutputFormat(str, Enum):
+    JSON = "json"
+    MSGPACK = "msgpack"
+
+
+@dataclass
+class AnalysisOptions:
+    input: Path
+    output: Optional[Path] = None
+    format: OutputFormat = OutputFormat.JSON
+    analysis_level: int = 1
+    using_codeql: bool = False
+    using_ray: bool = False
+    rebuild_analysis: bool = False
+    skip_tests: bool = True
+    file_name: Optional[Path] = None
+    cache_dir: Optional[Path] = None
+    clear_cache: bool = False
+    verbosity: int = 0

codeanalyzer_python-0.1.12/codeanalyzer/schema/__init__.py

@@ -0,0 +1,72 @@
+from importlib.metadata import version, PackageNotFoundError
+from packaging.version import parse as parse_version
+
+from .py_schema import (
+    PyApplication,
+    PyCallable,
+    PyCallableParameter,
+    PyClass,
+    PyClassAttribute,
+    PyComment,
+    PyImport,
+    PyModule,
+    PyVariableDeclaration,
+)
+
+__all__ = [
+    "PyApplication",
+    "PyImport",
+    "PyComment",
+    "PyModule",
+    "PyClass",
+    "PyVariableDeclaration",
+    "PyCallable",
+    "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_python-0.1.12/pyproject.toml

@@ -0,0 +1,115 @@
+[project]
+name = "codeanalyzer-python"
+version = "0.1.12"
+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.9"
+
+dependencies = [
+    # jedi
+    "jedi>=0.18.0,<0.20.0; python_version < '3.11'",
+    "jedi<=0.19.2; python_version >= '3.11'",
+    # msgpack
+    "msgpack>=1.0.0,<1.0.7; python_version < '3.11'",
+    "msgpack>=1.0.7,<2.0.0; python_version >= '3.11'",
+    # networkx
+    "networkx>=2.6.0,<3.2.0; python_version < '3.11'",
+    "networkx>=3.0.0,<4.0.0; python_version >= '3.11'",
+    # pandas
+    "pandas>=1.3.0,<2.0.0; python_version < '3.11'",
+    "pandas>=2.0.0,<3.0.0; python_version >= '3.11'",
+    # numpy
+    "numpy>=1.21.0,<1.24.0; python_version < '3.11'",
+    "numpy>=1.24.0,<2.0.0; python_version >= '3.11' and python_version < '3.12'",
+    "numpy>=1.26.0,<2.0.0; python_version >= '3.12'",
+    # pydantic
+    "pydantic>=1.8.0,<2.0.0; python_version < '3.11'",
+    "pydantic>=2.0.0,<3.0.0; python_version >= '3.11'",
+    # requests
+    "requests>=2.20.0,<3.0.0; python_version >= '3.11'",
+    # rich
+    "rich>=12.6.0,<14.0.0; python_version < '3.11'",
+    "rich>=14.0.0,<15.0.0; python_version >= '3.11'",
+    # typer
+    "typer>=0.9.0,<1.0.0; python_version < '3.11'",
+    "typer>=0.9.0,<2.0.0; python_version >= '3.11'",
+    # typing-extensions
+    "typing-extensions>=4.0.0,<5.0.0; python_version < '3.11'",
+    "typing-extensions>=4.5.0,<6.0.0; python_version >= '3.11'",
+    # ray
+    "ray==2.0.0; python_version < '3.11'",
+    "ray>=2.10.0,<3.0.0; python_version >= '3.11'",
+    "packaging>=25.0",
+]
+
+[dependency-groups]
+test = [
+  "pytest>=7.0.0,<8.0.0",
+  "pytest-asyncio>=0.14.0,<0.15.0",
+  "pytest-cov>=2.10.0,<3.0.0",
+  "pytest-pspec>=0.0.3"
+]
+dev = [
+  "ipdb>=0.13.0,<0.14.0",
+  "pre-commit>=2.9.0,<3.0.0"
+]
+
+[project.scripts]
+codeanalyzer = "codeanalyzer.__main__:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["codeanalyzer"]
+include = ["codeanalyzer/py.typed"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "codeanalyzer",
+  "codeanalyzer/py.typed",
+  "README.md",
+  "LICENSE",
+  "NOTICE"
+]
+
+[tool.pytest.ini_options]
+addopts = [
+  "-p", "coverage",
+  "--cov=codeanalyzer",
+  "--cov-report=html",
+  "--cov-report=term-missing",
+  "--cov-fail-under=40",
+  "--ignore=test/fixtures"
+]
+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.10/codeanalyzer/__main__.py

@@ -1,145 +0,0 @@
-from pathlib import Path
-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
-
-def main(
-    input: Annotated[
-        Path, typer.Option("-i", "--input", help="Path to the project root directory.")
-    ],
-    output: Annotated[
-        Optional[Path],
-        typer.Option("-o", "--output", help="Output directory for artifacts."),
-    ] = None,
-    format: Annotated[
-        OutputFormat,
-        typer.Option(
-            "-f",
-            "--format",
-            help="Output format: json or msgpack.",
-            case_sensitive=False,
-        ),
-    ] = OutputFormat.JSON,
-    analysis_level: Annotated[
-        int,
-        typer.Option("-a", "--analysis-level", help="1: symbol table, 2: call graph."),
-    ] = 1,
-    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(
-            "--eager/--lazy",
-            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. Defaults to '.codeanalyzer' in the input directory.",
-        ),
-    ] = None,
-    clear_cache: Annotated[
-        bool,
-        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,
-):
-    """Static Analysis on Python source code using Jedi, Astroid, and Treesitter."""
-    _set_log_level(verbosity)
-
-    if not input.exists():
-        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, 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)
-            print(artifacts.json(separators=(",", ":")))
-        else:
-            # Output to file
-            output.mkdir(parents=True, exist_ok=True)
-            _write_output(artifacts, output, format)
-
-
-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.json(indent=None)
-        with output_file.open("w") as f:
-            f.write(json_str)
-        logger.info(f"Analysis saved to {output_file}")
-
-    elif format == OutputFormat.MSGPACK:
-        output_file = output_dir / "analysis.msgpack"
-        msgpack_data = artifacts.to_msgpack_bytes()
-        with output_file.open("wb") as f:
-            f.write(msgpack_data)
-        logger.info(f"Analysis saved to {output_file}")
-        logger.info(
-            f"Compression ratio: {artifacts.get_compression_ratio():.1%} of JSON size"
-        )
-
-
-app = typer.Typer(
-    callback=main,
-    name="codeanalyzer",
-    help="Static Analysis on Python source code using Jedi, CodeQL and Tree sitter.",
-    invoke_without_command=True,
-    no_args_is_help=True,
-    add_completion=False,
-    rich_markup_mode="rich",
-    pretty_exceptions_show_locals=False,
-)
-
-if __name__ == "__main__":
-    app()

codeanalyzer_python-0.1.10/codeanalyzer/schema/__init__.py

@@ -1,33 +0,0 @@
-from .py_schema import (
-    PyApplication,
-    PyCallable,
-    PyCallableParameter,
-    PyClass,
-    PyClassAttribute,
-    PyComment,
-    PyImport,
-    PyModule,
-    PyVariableDeclaration,
-)
-
-__all__ = [
-    "PyApplication",
-    "PyImport",
-    "PyComment",
-    "PyModule",
-    "PyClass",
-    "PyVariableDeclaration",
-    "PyCallable",
-    "PyClassAttribute",
-    "PyCallableParameter",
-]
-
-# Resolve forward references
-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
-)

codeanalyzer_python-0.1.10/pyproject.toml

@@ -1,92 +0,0 @@
-[project]
-name = "codeanalyzer-python"
-version = "0.1.10"
-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.9"
-
-dependencies = [
-    "jedi>=0.18.0,<0.20.0",
-    "msgpack>=1.0.0,<1.0.7",
-    "networkx>=2.6.0,<3.2.0",
-    "pandas>=1.3.0,<2.0.0",
-    "numpy>=1.21.0,<1.24.0",
-    "pydantic>=1.8.0,<2.0.0",
-    "requests>=2.20.0,<3.0.0",
-    "rich>=12.6.0,<14.0.0",
-    "typer>=0.9.0,<1.0.0",
-    "ray>=2.0.0,<3.0.0",
-    "typing-extensions>=4.0.0"
-]
-
-[dependency-groups]
-test = [
-    "pytest>=7.0.0,<8.0.0",
-    "pytest-asyncio>=0.14.0,<0.15.0",
-    "pytest-cov>=2.10.0,<3.0.0",
-    "pytest-pspec>=0.0.3"
-]
-dev = [
-    "ipdb>=0.13.0,<0.14.0",
-    "pre-commit>=2.9.0,<3.0.0"
-]
-
-[project.scripts]
-codeanalyzer = "codeanalyzer.__main__:app"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["codeanalyzer"]
-include = ["codeanalyzer/py.typed"]
-
-[tool.hatch.build.targets.sdist]
-include = [
-    "codeanalyzer",
-    "codeanalyzer/py.typed",
-    "README.md",
-    "LICENSE",
-    "NOTICE"
-]
-
-[tool.pytest.ini_options]
-addopts = [
-    "-p", "coverage",
-    "--cov=codeanalyzer",
-    "--cov-report=html",
-    "--cov-report=term-missing",
-    "--cov-fail-under=40",
-    "--ignore=test/fixtures"
-]
-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"