metripy 0.2.7__py3-none-any.whl

metripy/LangAnalyzer/Typescript/TypescriptBasicComplexityAnalyzer.py

@@ -0,0 +1,114 @@
+import re
+
+
+class TypescriptBasicComplexityAnalzyer:
+    def get_complexity(self, code: str, function_name: str) -> dict[str, int] | None:
+        function_scope = self._extract_function(code, function_name)
+        if not function_scope:
+            return None
+        (start_index, end_index, start_line, end_line) = function_scope
+        function_code = code[start_index:end_index]
+
+        complexity = self._determine_complexity(function_code)
+
+        return {
+            "start_line": start_line,
+            "end_line": end_line,
+            "complexity": complexity,
+        }
+
+    def _determine_complexity(self, function_code: str) -> int:
+        complexity = 1
+
+        # Keywords that increase complexity
+        keywords = [
+            r"\bif\b",
+            r"\bfor\b",
+            r"\bwhile\b",
+            r"\bcase\b",
+            r"\bcatch\b",
+            r"\?\s*",
+            r"\belse\s+if\b",
+            r"\breturn\b.*\?",
+            r"\bthrow\b.*\?",
+            r"&&",
+            r"\|\|",
+        ]
+
+        for keyword in keywords:
+            matches = re.findall(keyword, function_code)
+            complexity += len(matches)
+
+        return complexity
+
+    def _extract_function(
+        self, code: str, function_name: str
+    ) -> tuple[int, int, int, int] | None:
+        # This pattern matches various JavaScript/TypeScript function declarations:
+        # 1. Arrow functions:
+        #    - With or without `export`
+        #    - With or without `async`
+        #    - With or without generics (`<T>`)
+        #    - With or without return types (`: Type`)
+        #    - With multiline or single-line parameters
+        #    - Including curried arrow functions (arrow returning another arrow)
+        # 2. Traditional functions:
+        #    - With optional `export` and `async`
+        # 3. Class methods:
+        #    - With optional access modifiers (`public`, `private`, `protected`)
+        #    - With optional `static` and `async`
+        #    - With optional generics and return types
+        # 4. Bare class methods (no modifiers)
+
+        pattern = re.compile(
+            rf"""
+            (
+                (export\s+)?(const|let|var)\s+{re.escape(function_name)}\s*
+                (<[^>]*>)?\s*=\s*(async\s+)?\(\s*.*?\s*\)\s*
+                (:\s*[^=]+)?\s*=>\s*
+                (\s*\(\s*.*?\s*\)\s*=>)?\s*\{{?
+            )
+            |
+            (
+                (export\s+)?(async\s+)?function\s+{re.escape(function_name)}\s*
+                \(\s*.*?\s*\)\s*\{{
+            )
+            |
+            (
+                (?:public|private|protected)?\s*
+                (?:static\s+)?(?:async\s+)?{re.escape(function_name)}\s*
+                (<[^>]+>)?\s*\(\s*.*?\s*\)\s*
+                (:\s*[^\{{]+)?\s*\{{
+            )
+            |
+            (
+                {re.escape(function_name)}\s*\(\s*.*?\s*\)\s*\{{
+            )
+            """,
+            re.MULTILINE | re.DOTALL | re.VERBOSE,
+        )
+
+        match = pattern.search(code)
+        if not match:
+            print(f"Function '{function_name}' not found.")
+            return None
+
+        start_index = match.start()
+        start_line = code[:start_index].count("\n") + 1
+
+        # Find the matching closing brace
+        brace_count = 0
+        i = match.end() - 1
+        while i < len(code):
+            if code[i] == "{":
+                brace_count += 1
+            elif code[i] == "}":
+                brace_count -= 1
+                if brace_count == 0:
+                    end_index = i + 1
+                    end_line = code[:end_index].count("\n") + 1
+                    return (start_index, end_index, start_line, end_line)
+            i += 1
+
+        print(f"Function '{function_name}' seems to be incomplete or malformed.")
+        return None

metripy/LangAnalyzer/Typescript/TypescriptBasicLocAnalyzer.py

@@ -0,0 +1,69 @@
+class TypescriptBasicLocAnalyzer:
+    @staticmethod
+    def get_loc_metrics(code: str, filename: str) -> dict:
+        """Fallback LOC calculation using manual analysis"""
+        try:
+            lines = code.split("\n")
+
+            total_lines = len(lines)
+            blank_lines = TypescriptBasicLocAnalyzer._count_blank_lines(lines)
+            comment_lines = TypescriptBasicLocAnalyzer._count_comment_lines(lines)
+            code_lines = total_lines - blank_lines - comment_lines
+
+            return {
+                "lines": total_lines,
+                "linesOfCode": code_lines,
+                "logicalLinesOfCode": code_lines,
+                "commentLines": comment_lines,
+                "blankLines": blank_lines,
+            }
+        except Exception as e:
+            print(f"Fallback LOC analysis failed: {e}")
+            return {
+                "lines": 0,
+                "linesOfCode": 0,
+                "logicalLinesOfCode": 0,
+                "commentLines": 0,
+                "blankLines": 0,
+            }
+
+    @staticmethod
+    def _count_blank_lines(lines: list) -> int:
+        """Count blank lines"""
+        return sum(1 for line in lines if not line.strip())
+
+    @staticmethod
+    def _count_comment_lines(lines: list) -> int:
+        """Count comment lines (single-line and multi-line)"""
+        comment_count = 0
+        in_multiline_comment = False
+
+        for line in lines:
+            stripped = line.strip()
+
+            # Handle multi-line comments
+            if "/*" in stripped:
+                in_multiline_comment = True
+                comment_count += 1
+                # Check if comment closes on same line
+                if "*/" in stripped:
+                    in_multiline_comment = False
+                continue
+
+            if in_multiline_comment:
+                comment_count += 1
+                if "*/" in stripped:
+                    in_multiline_comment = False
+                continue
+
+            # Handle single-line comments
+            if stripped.startswith(("//")) or stripped.startswith("#"):
+                comment_count += 1
+                continue
+
+            # Handle doc comments
+            if stripped.startswith("*") and not stripped.startswith("*/"):
+                comment_count += 1
+                continue
+
+        return comment_count

metripy/LangAnalyzer/Typescript/TypescriptHalSteadAnalyzer.py

@@ -0,0 +1,55 @@
+from metripy.LangAnalyzer.Generic.HalSteadAnalyzer import HalSteadAnalyzer
+
+
+class TypeScriptHalSteadAnalyzer:
+    def __init__(self):
+        self.operators = set(
+            [
+                "+",
+                "-",
+                "*",
+                "/",
+                "%",
+                "++",
+                "--",
+                "==",
+                "!=",
+                "===",
+                "!==",
+                "<",
+                ">",
+                "<=",
+                ">=",
+                "&&",
+                "||",
+                "!",
+                "=",
+                "+=",
+                "-=",
+                "*=",
+                "/=",
+                "%=",
+                "&",
+                "|",
+                "^",
+                "~",
+                "<<",
+                ">>",
+                "?",
+                ":",
+                ".",
+                ",",
+                ";",
+                "=>",
+                "(",
+                ")",
+                "[",
+                "]",
+                "{",
+                "}",
+            ]
+        )
+        self.analyzer = HalSteadAnalyzer(self.operators)
+
+    def calculate_halstead_metrics(self, code: str):
+        return self.analyzer.calculate_halstead_metrics(code)

metripy/Metric/Code/AggregatedMetrics.py

@@ -0,0 +1,42 @@
+from metripy.Metric.Code.SegmentedMetrics import SegmentedMetrics
+
+
+class AggregatedMetrics:
+    """Used to show aggregated metrics on the index page"""
+
+    def __init__(
+        self,
+        loc: int = 0,
+        avgCcPerFunction: float = 0.0,
+        maintainabilityIndex: float = 0.0,
+        avgLocPerFunction: float = 0.0,
+        num_files: int = 0,
+        segmented_loc: SegmentedMetrics = SegmentedMetrics(),
+        segmented_complexity: SegmentedMetrics = SegmentedMetrics(),
+        segmented_maintainability: SegmentedMetrics = SegmentedMetrics(),
+        segmented_method_size: SegmentedMetrics = SegmentedMetrics(),
+    ) -> None:
+        self.loc = loc
+        self.avgCcPerFunction = avgCcPerFunction
+        self.maintainabilityIndex = maintainabilityIndex
+        self.avgLocPerFunction = avgLocPerFunction
+        self.num_files = num_files
+
+        self.segmentation_data = {
+            "loc": segmented_loc,
+            "complexity": segmented_complexity,
+            "maintainability": segmented_maintainability,
+            "methodSize": segmented_method_size,
+        }
+
+    def to_dict(self) -> dict:
+        return {
+            "loc": str(self.loc),
+            "avgCcPerFunction": f"{self.avgCcPerFunction:.2f}",
+            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
+            "avgLocPerFunction": f"{self.avgLocPerFunction:.2f}",
+            "num_files": str(self.num_files),
+        }
+
+    def to_dict_segmentation(self) -> dict:
+        return {k: v.to_dict() for k, v in self.segmentation_data.items()}

metripy/Metric/Code/FileMetrics.py

@@ -0,0 +1,33 @@
+from metripy.Tree.ClassNode import ClassNode
+from metripy.Tree.FunctionNode import FunctionNode
+
+
+class FileMetrics:
+    def __init__(
+        self,
+        full_name: str,
+        loc: int,
+        avgCcPerFunction: float,
+        maintainabilityIndex: float,
+        avgLocPerFunction: float,
+        class_nodes: list[ClassNode],
+        function_nodes: list[FunctionNode],
+    ):
+        self.full_name = full_name
+        self.loc = loc
+        self.avgCcPerFunction = avgCcPerFunction
+        self.maintainabilityIndex = maintainabilityIndex
+        self.avgLocPerFunction = avgLocPerFunction
+        self.class_nodes = class_nodes
+        self.function_nodes = function_nodes
+
+    def to_dict(self) -> dict:
+        return {
+            "full_name": self.full_name,
+            "loc": self.loc,
+            "avgCcPerFunction": self.avgCcPerFunction,
+            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
+            "avgLocPerFunction": self.avgLocPerFunction,
+            "class_nodes": [node.to_dict() for node in self.class_nodes],
+            "function_nodes": [node.to_dict() for node in self.function_nodes],
+        }

metripy/Metric/Code/ModuleMetrics.py

@@ -0,0 +1,32 @@
+from metripy.Tree.ClassNode import ClassNode
+from metripy.Tree.FunctionNode import FunctionNode
+
+
+class ModuleMetrics:
+    def __init__(
+        self,
+        loc: int,
+        avgCcPerFunction: float,
+        maintainabilityIndex: float,
+        avgLocPerFunction: float,
+        class_nodes: list[ClassNode],
+        function_nodes: list[FunctionNode],
+    ):
+        self.loc = loc
+        self.avgCcPerFunction = avgCcPerFunction
+        self.maintainabilityIndex = maintainabilityIndex
+        self.avgLocPerFunction = avgLocPerFunction
+        self.num_files = 1
+        self.class_nodes: list[ClassNode] = class_nodes
+        self.function_nodes: list[FunctionNode] = function_nodes
+
+    def to_dict(self) -> dict:
+        return {
+            "loc": str(self.loc),
+            "avgCcPerFunction": f"{self.avgCcPerFunction:.2f}",
+            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
+            "avgLocPerFunction": f"{self.avgLocPerFunction:.2f}",
+            "num_files": str(self.num_files),
+            "class_nodes": [node.to_dict() for node in self.class_nodes],
+            "function_nodes": [node.to_dict() for node in self.function_nodes],
+        }

metripy/Metric/Code/SegmentedMetrics.py

@@ -0,0 +1,65 @@
+from typing import Self
+
+
+class SegmentedMetrics:
+    def __init__(self):
+        self.good = 0
+        self.ok = 0
+        self.warning = 0
+        self.critical = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "good": self.good,
+            "ok": self.ok,
+            "warning": self.warning,
+            "critical": self.critical,
+        }
+
+    def set_loc(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 200:
+                self.good += 1
+            elif value <= 500:
+                self.ok += 1
+            elif value <= 1000:
+                self.warning += 1
+            else:
+                self.critical += 1
+        return self
+
+    def set_complexity(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 5:
+                self.good += 1
+            elif value <= 10:
+                self.ok += 1
+            elif value <= 20:
+                self.warning += 1
+            else:
+                self.critical += 1
+        return self
+
+    def set_maintainability(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 80:
+                self.critical += 1
+            elif value <= 60:
+                self.warning += 1
+            elif value <= 40:
+                self.ok += 1
+            else:
+                self.good += 1
+        return self
+
+    def set_method_size(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 15:
+                self.good += 1
+            elif value <= 30:
+                self.ok += 1
+            elif value <= 50:
+                self.warning += 1
+            else:
+                self.critical += 1
+        return self

metripy/Metric/FileTree/FileTree.py

@@ -0,0 +1,15 @@
+from typing import Self
+
+
+class FileTree:
+    def __init__(self, name: str, full_name: str, children: list[Self] | None = None):
+        self.name = name
+        self.full_name = full_name
+        self.children: list[Self] = children if children is not None else []
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "full_name": self.full_name,
+            "children": [child.to_dict() for child in self.children],
+        }

metripy/Metric/FileTree/FileTreeParser.py

@@ -0,0 +1,42 @@
+from metripy.Metric.FileTree.FileTree import FileTree
+
+
+class FileTreeParser:
+    @staticmethod
+    def parse(paths: list[str], shorten: bool = False) -> FileTree:
+        root = FileTree(".", ".")
+
+        for path in paths:
+            parts = path.strip("./").split("/")
+            current = root
+
+            for part in parts:
+                # Check if part already exists in current children
+                found = next(
+                    (child for child in current.children if child.name == part), None
+                )
+                if not found:
+                    found = FileTree(part, path)
+                    current.children.append(found)
+                current = found
+
+        if shorten:
+            FileTreeParser._shorten_tree(root)
+
+        return root
+
+    @staticmethod
+    def _shorten_tree(node: FileTree):
+        """shorten tree nodes that only have a single child"""
+        while len(node.children) == 1:
+            child = node.children[0]
+            node.name += "/" + child.name
+            node.full_name = child.full_name
+            node.children = child.children
+
+        for child in node.children:
+            FileTreeParser._shorten_tree(child)
+
+        # print(json.dumps(root.to_dict(), indent=4))
+        # exit()
+        # return root

metripy/Metric/Git/GitCodeHotspot.py

@@ -0,0 +1,37 @@
+class GitCodeHotspot:
+
+    def __init__(self, file_path: str, changes_count: int, contributors_count: int):
+        self.file_path = file_path
+        self.changes_count = changes_count
+        self.contributors_count = contributors_count
+        self.risk_level = self._calc_risk_level(changes_count, contributors_count)
+        self.risk_label = self._label_from_risk_level()
+
+    def _calc_risk_level(self, changes_count: int, contributors_count: int) -> str:
+        if changes_count < 10:
+            if contributors_count < 5:
+                return "low"
+            else:
+                return "medium"
+        elif changes_count < 50:
+            if contributors_count < 5:
+                return "medium"
+            else:
+                return "high"
+        else:
+            if contributors_count < 1:
+                return "medium"
+            else:
+                return "high"
+
+    def _label_from_risk_level(self) -> str:
+        return self.risk_level.capitalize()
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "file_path": self.file_path,
+            "changes_count": self.changes_count,
+            "risk_level": self.risk_level,
+            "risk_label": self.risk_label,
+            "contributors_count": self.contributors_count,
+        }

metripy/Metric/Git/GitContributor.py

@@ -0,0 +1,37 @@
+class GitContributor:
+    def __init__(
+        self,
+        name: str,
+        commits_count: int,
+        lines_added: int,
+        lines_removed: int,
+        contribution_percentage: int,
+    ):
+        self.name = name
+        self.initials = self._get_initials(name)
+        self.commits_count = commits_count
+        self.lines_added = lines_added
+        self.lines_removed = lines_removed
+        self.contribution_percentage = contribution_percentage
+
+    def _get_initials(self, name: str) -> str:
+        try:
+            parts = name.split()
+            if len(parts) >= 2:
+                return (parts[0][0] + parts[1][0]).upper()
+            elif len(parts) == 1:
+                return parts[0][:2].upper()
+            else:
+                return "UN"
+        except Exception:
+            return "UN"
+
+    def to_dict(self) -> dict[str, int]:
+        return {
+            "name": self.name,
+            "initials": self.initials,
+            "commits_count": self.commits_count,
+            "lines_added": self.lines_added,
+            "lines_removed": self.lines_removed,
+            "contribution_percentage": self.contribution_percentage,
+        }

metripy/Metric/Git/GitKnowledgeSilo.py

@@ -0,0 +1,27 @@
+class GitKnowledgeSilo:
+    def __init__(self, file_path: str, owner: str, commits_count: int):
+        self.file_path = file_path
+        self.owner = owner
+        self.commits_count = commits_count
+        self.risk_level = self._calc_risk_level(commits_count)
+        self.risk_label = self._calc_risk_label(self.risk_level)
+
+    def _calc_risk_level(self, commits_count: int) -> str:
+        if commits_count >= 15:
+            return "high"
+        elif commits_count >= 8:
+            return "medium"
+        else:
+            return "low"
+
+    def _calc_risk_label(self, risk_level: str) -> str:
+        return risk_level.capitalize()
+
+    def to_dict(self) -> dict[str, int]:
+        return {
+            "file_path": f"{self.file_path}",
+            "owner": f"{self.owner}",
+            "commits_count": f"{self.commits_count}",
+            "risk_level": f"{self.risk_level}",
+            "risk_label": f"{self.risk_label}",
+        }