complexipy 4.1.0__tar.gz → 4.2.0__tar.gz

{complexipy-4.1.0 → complexipy-4.2.0}/Cargo.lock

@@ -107,7 +107,7 @@ dependencies = [
 
 [[package]]
 name = "complexipy"
-version = "4.1.0"
+version = "4.2.0"
 dependencies = [
  "console_error_panic_hook",
  "csv",

{complexipy-4.1.0 → complexipy-4.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "complexipy"
-version = "4.1.0"
+version = "4.2.0"
 edition = "2024"
 authors = ["Robin Quintero <rohaquinlop301@gmail.com>"]
 license = "MIT"

{complexipy-4.1.0 → complexipy-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: complexipy
-Version: 4.1.0
+Version: 4.2.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -33,7 +33,7 @@ Project-URL: Repository, https://github.com/rohaquinlop/complexipy
 # complexipy
 
 <div align="center">
-  <img src="docs/img/complexipy_icon.svg" alt="complexipy" width="120" height="120">
+  <img src="https://raw.githubusercontent.com/rohaquinlop/complexipy/refs/heads/main/docs/img/complexipy_icon.svg" alt="complexipy" width="120" height="120">
   
   <p><em>Blazingly fast cognitive complexity analysis for Python, written in Rust.</em></p>
 
@@ -86,6 +86,9 @@ complexipy . --max-complexity-allowed 10
 
 # Save results to JSON/CSV
 complexipy . --output-json --output-csv
+
+# Analyze current directory while excluding specific files
+complexipy . --exclude path/to/exclude.py --exclude path/to/other/exclude.py
 ```
 
 ### Python API
@@ -168,6 +171,7 @@ quiet = false
 ignore-complexity = false
 details = "normal"
 sort = "asc"
+exclude = []
 
 [output]
 csv = true
@@ -183,6 +187,7 @@ quiet = false
 ignore-complexity = false
 details = "normal"
 sort = "asc"
+exclude = []
 
 [tool.complexipy.output]
 csv = true
@@ -193,6 +198,7 @@ json = true
 
 | Flag | Description | Default |
 |------|-------------|---------|
+| `--exclude` | Exclude entries relative to each provided path. Entries resolve to existing directories (prefix match) or files (exact match). Non-existent entries are ignored. |  |
 | `--max-complexity-allowed` | Complexity threshold | `15` |
 | `--output-json` | Save results as JSON | `false` |
 | `--output-csv` | Save results as CSV | `false` |
@@ -202,6 +208,28 @@ json = true
 | `--ignore-complexity` | Don't exit with error on threshold breach | `false` |
 | `--version` | Show installed complexipy version and exit | - |
 
+Example:
+
+```
+# Exclude only top-level 'tests' directory under the provided root
+complexipy . --exclude tests
+# This will not exclude './complexipy/utils.py' if you pass '--exclude utils' at repo root,
+# because there is no './utils' directory or file at that level.
+```
+
+### Inline Ignores
+
+You can explicitly ignore a known complex function inline, similar to Ruff's `C901` ignores:
+
+```python
+def legacy_adapter(x, y):  # noqa: complexipy (safe wrapper)
+    if x and y:
+        return x + y
+    return 0
+```
+
+Place `# noqa: complexipy` on the function definition line (or the line immediately above). An optional reason can be provided in parentheses or plain text, it’s ignored by the parser.
+
 ## API Reference
 
 ```python
@@ -226,11 +254,11 @@ FunctionComplexity:
 
 <div align="center">
 
+<sub>Inspired by the <a href="https://www.sonarsource.com/resources/cognitive-complexity/">Cognitive Complexity</a> research by SonarSource, G. Ann Campbell</sub>
+
 **[Documentation](https://rohaquinlop.github.io/complexipy/) • [PyPI](https://pypi.org/project/complexipy/) • [GitHub](https://github.com/rohaquinlop/complexipy)**
 
 <sub>Built with ❤️ by <a href="https://github.com/rohaquinlop">@rohaquinlop</a> and <a href="https://github.com/rohaquinlop/complexipy/graphs/contributors">contributors</a></sub>
 
-<sub>Inspired by the <a href="https://www.sonarsource.com/resources/cognitive-complexity/">Cognitive Complexity</a> research by SonarSource</sub>
-
 </div>
 

{complexipy-4.1.0 → complexipy-4.2.0}/README.md

@@ -1,7 +1,7 @@
 # complexipy
 
 <div align="center">
-  <img src="docs/img/complexipy_icon.svg" alt="complexipy" width="120" height="120">
+  <img src="https://raw.githubusercontent.com/rohaquinlop/complexipy/refs/heads/main/docs/img/complexipy_icon.svg" alt="complexipy" width="120" height="120">
   
   <p><em>Blazingly fast cognitive complexity analysis for Python, written in Rust.</em></p>
 
@@ -54,6 +54,9 @@ complexipy . --max-complexity-allowed 10
 
 # Save results to JSON/CSV
 complexipy . --output-json --output-csv
+
+# Analyze current directory while excluding specific files
+complexipy . --exclude path/to/exclude.py --exclude path/to/other/exclude.py
 ```
 
 ### Python API
@@ -136,6 +139,7 @@ quiet = false
 ignore-complexity = false
 details = "normal"
 sort = "asc"
+exclude = []
 
 [output]
 csv = true
@@ -151,6 +155,7 @@ quiet = false
 ignore-complexity = false
 details = "normal"
 sort = "asc"
+exclude = []
 
 [tool.complexipy.output]
 csv = true
@@ -161,6 +166,7 @@ json = true
 
 | Flag | Description | Default |
 |------|-------------|---------|
+| `--exclude` | Exclude entries relative to each provided path. Entries resolve to existing directories (prefix match) or files (exact match). Non-existent entries are ignored. |  |
 | `--max-complexity-allowed` | Complexity threshold | `15` |
 | `--output-json` | Save results as JSON | `false` |
 | `--output-csv` | Save results as CSV | `false` |
@@ -170,6 +176,28 @@ json = true
 | `--ignore-complexity` | Don't exit with error on threshold breach | `false` |
 | `--version` | Show installed complexipy version and exit | - |
 
+Example:
+
+```
+# Exclude only top-level 'tests' directory under the provided root
+complexipy . --exclude tests
+# This will not exclude './complexipy/utils.py' if you pass '--exclude utils' at repo root,
+# because there is no './utils' directory or file at that level.
+```
+
+### Inline Ignores
+
+You can explicitly ignore a known complex function inline, similar to Ruff's `C901` ignores:
+
+```python
+def legacy_adapter(x, y):  # noqa: complexipy (safe wrapper)
+    if x and y:
+        return x + y
+    return 0
+```
+
+Place `# noqa: complexipy` on the function definition line (or the line immediately above). An optional reason can be provided in parentheses or plain text, it’s ignored by the parser.
+
 ## API Reference
 
 ```python
@@ -194,10 +222,10 @@ FunctionComplexity:
 
 <div align="center">
 
+<sub>Inspired by the <a href="https://www.sonarsource.com/resources/cognitive-complexity/">Cognitive Complexity</a> research by SonarSource, G. Ann Campbell</sub>
+
 **[Documentation](https://rohaquinlop.github.io/complexipy/) • [PyPI](https://pypi.org/project/complexipy/) • [GitHub](https://github.com/rohaquinlop/complexipy)**
 
 <sub>Built with ❤️ by <a href="https://github.com/rohaquinlop">@rohaquinlop</a> and <a href="https://github.com/rohaquinlop/complexipy/graphs/contributors">contributors</a></sub>
 
-<sub>Inspired by the <a href="https://www.sonarsource.com/resources/cognitive-complexity/">Cognitive Complexity</a> research by SonarSource</sub>
-
 </div>

{complexipy-4.1.0 → complexipy-4.2.0}/complexipy/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from complexipy._complexipy import (
     CodeComplexity,
     FileComplexity,

{complexipy-4.1.0 → complexipy-4.2.0}/complexipy/main.py

@@ -51,6 +51,12 @@ def main(
         None,
         help="Paths to the directories or files to analyze, it can be a local paths or a git repository URL.",
     ),
+    exclude: Optional[List[str]] = typer.Option(
+        None,
+        "--exclude",
+        "-e",
+        help="Paths to the directories or files to exclude.",
+    ),
     max_complexity_allowed: Optional[int] = typer.Option(
         None,
         "--max-complexity-allowed",
@@ -110,6 +116,7 @@ def main(
         sort,
         output_csv,
         output_json,
+        exclude,
     ) = get_arguments_value(
         TOML_CONFIG,
         paths,
@@ -120,6 +127,7 @@ def main(
         sort,
         output_csv,
         output_json,
+        exclude,
     )
 
     if not quiet:
@@ -128,7 +136,9 @@ def main(
         else:
             console.rule(":octopus: complexipy")
     start_time = time.time()
-    result: Tuple[List[FileComplexity], List[str]] = _complexipy.main(paths, quiet)
+    result: Tuple[List[FileComplexity], List[str]] = _complexipy.main(
+        paths, quiet, exclude
+    )
     files_complexities, failed_paths = result
     execution_time = time.time() - start_time
     output_csv_path = f"{INVOCATION_PATH}/complexipy.csv"

{complexipy-4.1.0 → complexipy-4.2.0}/complexipy/utils.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import sys
 from complexipy.types import DetailTypes, Sort, TOMLType
@@ -35,11 +37,32 @@ def get_brain_icon():
         return ":brain:"
 
 
-def load_values_from_toml_key(value: str) -> TOMLType:
-    if value == "details":
-        DetailTypes[value]
-    if value == "sort":
-        Sort[value]
+def load_values_from_toml_key(key: str, value: TOMLType) -> TOMLType:
+    """Normalize TOML values to expected runtime types.
+
+    - Convert `details` and `sort` string values to their Enum variants.
+    - Ensure `paths` and `exclude` are lists when provided as strings.
+    """
+    if key == "details":
+        # Accept either Enum or string in TOML
+        if isinstance(value, DetailTypes):
+            return value
+        if isinstance(value, str):
+            return DetailTypes(value)
+        return value
+
+    if key == "sort":
+        if isinstance(value, Sort):
+            return value
+        if isinstance(value, str):
+            return Sort(value)
+        return value
+
+    if key in ("paths", "exclude"):
+        # Allow a single string, normalize to list for downstream processing
+        if isinstance(value, str):
+            return [value]
+        return value
 
     return value
 
@@ -69,7 +92,7 @@ def load_toml_config(invocation_path: str, config_file_name: str) -> TOMLType |
             return None
 
     for key, value in data.items():
-        data[key] = load_values_from_toml_key(value)
+        data[key] = load_values_from_toml_key(key, value)
 
     return data
 
@@ -125,7 +148,8 @@ def get_arguments_value(
     sort_arg: Sort | None,
     output_csv: bool | None,
     output_json: bool | None,
-) -> Tuple[List[str], int, bool, bool, DetailTypes, Sort, bool, bool]:
+    exclude: List[str] | None,
+) -> Tuple[List[str], int, bool, bool, DetailTypes, Sort, bool, bool, List[str]]:
     paths = get_argument_value(toml_config, "paths", paths)
     max_complexity_allowed = get_argument_value(
         toml_config, "max-complexity-allowed", max_complexity_allowed, 15
@@ -138,6 +162,7 @@ def get_arguments_value(
     sort_arg = get_argument_value(toml_config, "sort", sort_arg, Sort.asc)
     output_csv = get_argument_value(toml_config, "output-csv", output_csv, False)
     output_json = get_argument_value(toml_config, "output-json", output_json, False)
+    exclude = get_argument_value(toml_config, "exclude", exclude, [])
 
     return (
         paths,
@@ -148,6 +173,7 @@ def get_arguments_value(
         sort_arg,
         output_csv,
         output_json,
+        exclude,
     )
 
 

{complexipy-4.1.0 → complexipy-4.2.0}/complexipy.toml

@@ -1,9 +1,10 @@
-paths = ["src", "complexipy"]
+paths = ["."]
 max-complexity-allowed = 15
 quiet = false
 ignore-complexity = false
 details = "normal"
 sort = "asc"
+exclude = ["tests"]
 
 [output]
 csv = false

{complexipy-4.1.0 → complexipy-4.2.0}/docs/index.md

@@ -67,6 +67,10 @@ complexipy . --max-complexity-allowed 10
 
 # Generate reports
 complexipy . --output-json --output-csv
+
+# Analyze current directory while excluding specific files
+complexipy . --exclude file_to_exclude.py --exclude path/to/other/exclude.py
+
 ```
 
 ### Python API
@@ -131,6 +135,7 @@ quiet = false
 ignore-complexity = false
 details = "normal"
 sort = "asc"
+exclude = []
 
 [output]
 csv = true
@@ -148,6 +153,7 @@ quiet = false
 ignore-complexity = false
 details = "normal"
 sort = "asc"
+exclude = []
 
 [tool.complexipy.output]
 csv = true
@@ -161,6 +167,7 @@ json = true
 
 | Option | Description | Default |
 |--------|-------------|---------|
+| `--exclude` | Exclude entries relative to each provided path. Entries resolve to existing directories (prefix match) or files (exact match). Non-existent entries are ignored. |  |
 | `--max-complexity-allowed <N>` | Complexity threshold for warnings | `15` |
 | `--output-json` | Export results to JSON | `false` |
 | `--output-csv` | Export results to CSV | `false` |
@@ -181,11 +188,29 @@ complexipy . --max-complexity-allowed 8 --output-json
 
 # Silent analysis sorted by name
 complexipy src/ --sort name --quiet
+
+# Exclude specific paths relative to root
+complexipy . --exclude tests --exclude utils
+# Note: this excludes only './tests/**' and './utils/**' under '.',
+# it does not exclude './complexipy/utils.py'.
 ```
 
 !!! tip "Exit Codes"
     complexipy returns exit code `1` when functions exceed the complexity threshold. Use `--ignore-complexity` to suppress this behavior in CI/CD pipelines.
 
+### Inline Ignores
+
+You can explicitly ignore a known complex function inline, similar to Ruff's `C901` ignores:
+
+```python
+def legacy_adapter(x, y):  # noqa: complexipy (safe wrapper)
+    if x and y:
+        return x + y
+    return 0
+```
+
+Place `# noqa: complexipy` on the function definition line (or the line immediately above). An optional reason can be provided in parentheses or plain text, it’s ignored by the parser.
+
 ## API Reference
 
 ### Functions
@@ -366,7 +391,7 @@ def process_orders(orders):           # Base: 0
 ```bash
 $ complexipy example.py
 
-───────────────────────────── 🐙 complexipy 4.0.0 ──────────────────────────────
+───────────────────────────── 🐙 complexipy ──────────────────────────────
                                     Summary
            ┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
            ┃ Path       ┃ File       ┃ Function       ┃ Complexity ┃
@@ -385,7 +410,7 @@ $ complexipy example.py
 
 ## Links & Resources
 
-- **📚 [Research Paper](https://www.sonarsource.com/resources/cognitive-complexity/)** - Original cognitive complexity research by SonarSource
+- **📚 [Research Paper](https://www.sonarsource.com/resources/cognitive-complexity/)** - Original cognitive complexity research by SonarSource, G. Ann Campbell
 - **🐙 [GitHub Repository](https://github.com/rohaquinlop/complexipy)** - Source code and issue tracking  
 - **📦 [PyPI Package](https://pypi.org/project/complexipy/)** - Installation and version history
 - **🛠️ [GitHub Action](https://github.com/marketplace/actions/complexipy)** - CI/CD integration

{complexipy-4.1.0 → complexipy-4.2.0}/src/cognitive_complexity/mod.rs

@@ -2,7 +2,7 @@ pub mod utils;
 
 #[cfg(any(feature = "python", feature = "wasm"))]
 mod shared_deps {
-    pub use super::utils::{count_bool_ops, get_line_number, is_decorator};
+    pub use super::utils::{count_bool_ops, get_line_number, has_noqa_complexipy, is_decorator};
     pub use crate::classes::{CodeComplexity, FileComplexity, FunctionComplexity, LineComplexity};
     pub use ruff_python_ast::{self as ast, Stmt};
 }
@@ -37,28 +37,34 @@ type ComplexitiesAndFailedPaths = (Vec<FileComplexity>, Vec<String>);
 
 #[cfg(feature = "python")]
 #[pyfunction]
-pub fn main(paths: Vec<&str>, quiet: bool) -> PyResult<ComplexitiesAndFailedPaths> {
+pub fn main(
+    paths: Vec<&str>,
+    quiet: bool,
+    exclude: Vec<&str>,
+) -> PyResult<ComplexitiesAndFailedPaths> {
     let re = Regex::new(r"^(https:\/\/|http:\/\/|www\.|git@)(github|gitlab)\.com(\/[\w.-]+){2,}$")
         .unwrap();
 
-    let all_files_paths: Vec<(&str, bool, bool, bool)> = paths
+    let all_files_paths: Vec<(&str, bool, bool, bool, Vec<&str>)> = paths
         .iter()
         .map(|&path| {
             let is_url = re.is_match(path);
 
             if is_url {
-                (path, false, true, quiet)
+                (path, false, true, quiet, exclude.clone())
             } else if metadata(path).unwrap().is_dir() {
-                (path, true, false, quiet)
+                (path, true, false, quiet, exclude.clone())
             } else {
-                (path, false, false, quiet)
+                (path, false, false, quiet, exclude.clone())
             }
         })
         .collect();
 
     let all_files_processed: Vec<Result<ComplexitiesAndFailedPaths, PyErr>> = all_files_paths
         .iter()
-        .map(|(path, is_dir, is_url, quiet)| process_path(path, *is_dir, *is_url, *quiet))
+        .map(|(path, is_dir, is_url, quiet, exclude)| {
+            process_path(path, *is_dir, *is_url, *quiet, exclude.clone())
+        })
         .collect();
 
     let mut successful = Vec::new();
@@ -83,6 +89,7 @@ pub fn process_path(
     is_dir: bool,
     is_url: bool,
     quiet: bool,
+    exclude: Vec<&str>,
 ) -> Result<ComplexitiesAndFailedPaths, PyErr> {
     let mut file_complexities = Vec::new();
     let mut failed_paths = Vec::new();
@@ -121,13 +128,13 @@ pub fn process_path(
         }
 
         let repo_path = dir.path().join(&repo_name).to_str().unwrap().to_string();
-        let (complexities, f_paths) = evaluate_dir(&repo_path, quiet);
+        let (complexities, f_paths) = evaluate_dir(&repo_path, quiet, exclude.clone());
         dir.close()?;
 
         file_complexities = complexities;
         failed_paths = f_paths;
     } else if is_dir {
-        let (complexities, f_paths) = evaluate_dir(path, quiet);
+        let (complexities, f_paths) = evaluate_dir(path, quiet, exclude.clone());
         file_complexities = complexities;
         failed_paths = f_paths;
     } else {
@@ -149,18 +156,85 @@ pub fn process_path(
 }
 
 #[cfg(feature = "python")]
-fn evaluate_dir(path: &str, quiet: bool) -> ComplexitiesAndFailedPaths {
+fn evaluate_dir(path: &str, quiet: bool, exclude: Vec<&str>) -> ComplexitiesAndFailedPaths {
     let mut files_paths: Vec<String> = Vec::new();
 
     let parent_dir = path::Path::new(path).parent().unwrap().to_str().unwrap();
 
+    // Build path-aware exclude specs, relative to the provided root `path`.
+    // Only exclude if the exclude entry resolves to an existing directory (prefix match)
+    // or file (exact match) under the root. Otherwise, ignore the entry.
+    #[derive(Clone)]
+    struct ExcludeSpec {
+        // canonical, normalized absolute path
+        abs: String,
+        is_dir: bool,
+    }
+
+    let root_canon = match path::Path::new(path).canonicalize() {
+        Ok(p) => p,
+        Err(_) => path::PathBuf::from(path),
+    };
+
+    let mut exclude_specs: Vec<ExcludeSpec> = Vec::new();
+    for raw in exclude.iter() {
+        let mut candidate: path::PathBuf;
+        let p = path::Path::new(raw);
+        if p.is_absolute() {
+            candidate = p.to_path_buf();
+        } else {
+            candidate = root_canon.join(p);
+        }
+
+        // Resolve to canonical if possible
+        let (exists, is_dir, is_file, abs_str) = match candidate.canonicalize() {
+            Ok(canon) => {
+                let is_dir = canon.is_dir();
+                let is_file = canon.is_file();
+                let s = canon.to_string_lossy().replace('\\', "/");
+                (true, is_dir, is_file, s)
+            }
+            Err(_) => (false, false, false, String::new()),
+        };
+
+        if exists {
+            if is_dir || is_file {
+                exclude_specs.push(ExcludeSpec { abs: abs_str, is_dir });
+            }
+        }
+        // If it doesn't exist under the root, ignore the exclude entry
+    }
+
     // Get all the python files in the directory
     for entry in Walk::new(path) {
         let entry = entry.unwrap();
-        let file_path_str = entry.path().to_str().unwrap();
+        let entry_path = entry.path();
 
-        if entry.path().extension().and_then(|s| s.to_str()) == Some("py") {
-            files_paths.push(file_path_str.to_string());
+        if entry_path.extension().and_then(|s| s.to_str()) != Some("py") {
+            continue;
+        }
+
+        // Determine if this file should be excluded using path-aware specs
+        let file_abs = match entry_path.canonicalize() {
+            Ok(p) => p,
+            Err(_) => entry_path.to_path_buf(),
+        };
+        let file_abs_str = file_abs.to_string_lossy().replace('\\', "/");
+
+        let is_excluded = exclude_specs.iter().any(|spec| {
+            if spec.is_dir {
+                // Directory prefix match
+                file_abs_str.starts_with(&spec.abs)
+            } else {
+                // Exact file match
+                file_abs_str == spec.abs
+            }
+        });
+
+        if !is_excluded {
+            if let Some(file_path_str) = entry_path.to_str() {
+                files_paths.push(file_path_str.to_string());
+            }
         }
     }
 
@@ -289,34 +363,40 @@ pub fn function_level_cognitive_complexity_shared(
     for node in ast_body.iter() {
         match node {
             Stmt::FunctionDef(f) => {
-                let (func_complexity, line_complexities) =
-                    statement_cognitive_complexity_shared(node, 0, code);
-
-                let function = FunctionComplexity {
-                    name: f.name.to_string(),
-                    complexity: func_complexity,
-                    line_start: get_line_number(usize::from(f.range.start()), code),
-                    line_end: get_line_number(usize::from(f.range.end()), code),
-                    line_complexities,
-                };
-
-                functions.push(function);
+                let start_line = get_line_number(usize::from(f.range.start()), code);
+                if !has_noqa_complexipy(start_line, code) {
+                    let (func_complexity, line_complexities) =
+                        statement_cognitive_complexity_shared(node, 0, code);
+
+                    let function = FunctionComplexity {
+                        name: f.name.to_string(),
+                        complexity: func_complexity,
+                        line_start: start_line,
+                        line_end: get_line_number(usize::from(f.range.end()), code),
+                        line_complexities,
+                    };
+
+                    functions.push(function);
+                }
             }
             Stmt::ClassDef(c) => {
                 for node in c.body.iter() {
                     if let Stmt::FunctionDef(f) = node {
-                        let (func_complexity, line_complexities) =
-                            statement_cognitive_complexity_shared(node, 0, code);
-
-                        let function = FunctionComplexity {
-                            name: format!("{}::{}", c.name, f.name),
-                            complexity: func_complexity,
-                            line_start: get_line_number(usize::from(f.range.start()), code),
-                            line_end: get_line_number(usize::from(f.range.end()), code),
-                            line_complexities,
-                        };
-
-                        functions.push(function);
+                        let start_line = get_line_number(usize::from(f.range.start()), code);
+                        if !has_noqa_complexipy(start_line, code) {
+                            let (func_complexity, line_complexities) =
+                                statement_cognitive_complexity_shared(node, 0, code);
+
+                            let function = FunctionComplexity {
+                                name: format!("{}::{}", c.name, f.name),
+                                complexity: func_complexity,
+                                line_start: start_line,
+                                line_end: get_line_number(usize::from(f.range.end()), code),
+                                line_complexities,
+                            };
+
+                            functions.push(function);
+                        }
                     }
                 }
             }

{complexipy-4.1.0 → complexipy-4.2.0}/src/cognitive_complexity/utils.rs

@@ -241,3 +241,28 @@ pub fn get_line_number(byte_index: usize, code: &str) -> u64 {
     let newline_count = before_slice.chars().filter(|&c| c == '\n').count();
     (newline_count + 1) as u64
 }
+
+#[cfg(any(feature = "python", feature = "wasm"))]
+pub fn has_noqa_complexipy(line_number: u64, code: &str) -> bool {
+    if line_number == 0 {
+        return false;
+    }
+
+    let lines: Vec<&str> = code.lines().collect();
+    let idx = (line_number as usize).saturating_sub(1);
+
+    let contains_marker = |s: &str| -> bool {
+        let lower = s.to_lowercase();
+        lower.contains("noqa: complexipy")
+    };
+
+    if idx < lines.len() && contains_marker(lines[idx]) {
+        return true;
+    }
+
+    if idx > 0 && contains_marker(lines[idx - 1]) {
+        return true;
+    }
+
+    false
+}