commons-metrics 0.0.19__tar.gz → 0.0.20__tar.gz

{commons_metrics-0.0.19 → commons_metrics-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commons_metrics
-Version: 0.0.19
+Version: 0.0.20
 Summary: A simple library for basic statistical calculations
 Author: Bancolombia
 Author-email: omar.david.pino@email.com

{commons_metrics-0.0.19 → commons_metrics-0.0.20}/commons_metrics/__init__.py

@@ -4,6 +4,12 @@ from .repositories import ComponentRepository
 from .update_design_components import UpdateDesignSystemComponents
 from .github_api_client import GitHubAPIClient
 from .azure_devops_client import AzureDevOpsClient
+from .s3_file_manager import S3FileManager
+from .cache_manager import CacheManager
+from .commons_repos_client import CommonsReposClient
+from .date_utils import DateUtils
+from .text_simplifier import TextSimplifier
+from .variable_finder import VariableFinder
 
-__all__ = ['Util', 'DatabaseConnection', 'ComponentRepository', 'UpdateDesignSystemComponents', 'GitHubAPIClient', 'AzureDevOpsClient']
-__version__ = '0.0.19'
+__all__ = ['Util', 'DatabaseConnection', 'ComponentRepository', 'UpdateDesignSystemComponents', 'GitHubAPIClient', 'AzureDevOpsClient', 'S3FileManager', 'CacheManager', 'CommonsReposClient', 'DateUtils', 'TextSimplifier', 'VariableFinder']
+__version__ = '0.0.20'

commons_metrics-0.0.20/commons_metrics/cache_manager.py

@@ -0,0 +1,74 @@
+import requests
+import urllib3
+
+from .s3_file_manager import S3FileManager
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+class CacheManager:
+    """Manager for caching data in S3 and making API requests"""
+    
+    def __init__(self):
+        self.s3 = S3FileManager()
+    
+    def load_cache_or_fetch(self, path: str, fetch_fn, clear_cache: bool = False):
+        """
+        Load data from a JSON cache stored in S3 using S3FileManager,
+        or fetch the data and update the cache.
+
+        Args:
+            path (str): Cache key relative to "cache/", e.g. "logs/123.json"
+            fetch_fn (Callable): Function returning JSON-serializable data
+            clear_cache (bool): If True, delete existing cache before fetching
+        Returns:
+            Any: Cached or freshly fetched data
+        """
+        key = f"cache/{path}"
+        if clear_cache:
+            try:
+                self.s3.s3.delete_object(Bucket=self.s3.bucket, Key=key)
+            except Exception:
+                pass
+        data = self.s3.load_json(key)
+
+        if data:
+            return data
+
+        data = fetch_fn()
+        self.s3.save_json(data, key)
+
+        return data
+
+    def get_data_from_api(self, url: str, headers: dict, auth_api) -> list:
+        """
+        Sends a GET request to the specified API and returns the JSON response if successful.
+
+        Args:
+            url (str): The API endpoint URL.
+            headers (dict): HTTP headers for the request.
+            auth_api: Authentication object for the request.
+        Returns:
+            list or dict: JSON response from the API if successful, otherwise an empty list.
+        """
+        response = requests.get(url, headers=headers, auth=auth_api, verify=False)
+        if response.ok:
+            return response.json()
+        return []
+
+    def post_data_to_api(self, url: str, headers: dict, body: dict, auth_api) -> list:
+        """
+        Sends a POST request to the specified API with the given body and returns the JSON response if successful.
+
+        Args:
+            url (str): The API endpoint URL.
+            headers (dict): HTTP headers for the request.
+            body (dict): Data to send in the POST request.
+            auth_api: Authentication object for the request.
+        Returns:
+            list or dict: JSON response from the API if successful, otherwise an empty list.
+        """
+        response = requests.post(url, headers=headers, auth=auth_api, data=body, verify=False)
+        if response.ok:
+            return response.json()
+        return []

commons_metrics-0.0.20/commons_metrics/commons_repos_client.py

@@ -0,0 +1,118 @@
+"""
+Módulo con funciones compartidas entre clientes de repositorios (GitHub, Azure DevOps)
+"""
+import re
+import json
+from typing import Optional, Dict
+
+
+class CommonsReposClient:
+    """Utilidades compartidas para clientes de repositorios"""
+    
+    @staticmethod
+    def extract_package_version_from_pubspec(content: str, package_name: str) -> Optional[Dict]:
+        """
+        Extrae la versión de un paquete del contenido de pubspec.yaml
+        
+        Args:
+            content: Contenido del archivo pubspec.yaml
+            package_name: Nombre del paquete a buscar (ej: 'bds_mobile')
+            
+        Returns:
+            Diccionario con versión completa y major, o None
+        """
+        if not content:
+            return None
+        
+        # Patrones para diferentes formatos de versión (con posibles espacios antes)
+        # IMPORTANTE: debe estar en sección dependencies: para evitar falsos positivos
+        simple_patterns = [
+            # Formato simple: bds_mobile: ^8.127.0 (en la misma línea)
+            rf'^\s*{package_name}\s*:\s*\^?([0-9]+\.[0-9]+\.[0-9]+)',
+            # Formato con >= o ~
+            rf'^\s*{package_name}\s*:\s*>=([0-9]+\.[0-9]+\.[0-9]+)',
+            rf'^\s*{package_name}\s*:\s*~>([0-9]+\.[0-9]+\.[0-9]+)',
+        ]
+        
+        for pattern in simple_patterns:
+            match = re.search(pattern, content, re.MULTILINE)
+            if match:
+                version = match.group(1)
+                major_version = version.split('.')[0]
+                return {
+                    'full_version': version,
+                    'major_version': major_version
+                }
+        
+        # Formato hosted con artifactory (múltiples variantes)
+        hosted_patterns = [
+            # Patrón 1: hosted simple (una línea)
+            rf'^(\s*){package_name}\s*:\s*$\s*\1\s+hosted:\s*https?://.*?$\s*\1\s+version:\s*["\']?\^?([0-9]+\.[0-9]+\.[0-9]+)',
+            # Patrón 2: hosted con name/url (multilínea)
+            rf'^(\s*){package_name}\s*:\s*$\s*\1\s+hosted:\s*$.*?\s*\1\s+version:\s*["\']?\^?([0-9]+\.[0-9]+\.[0-9]+)',
+        ]
+        
+        for hosted_pattern in hosted_patterns:
+            hosted_match = re.search(hosted_pattern, content, re.MULTILINE | re.DOTALL)
+            if hosted_match:
+                # El último grupo siempre es la versión
+                version = hosted_match.groups()[-1]
+                major_version = version.split('.')[0]
+                return {
+                    'full_version': version,
+                    'major_version': major_version
+                }
+        
+        return None
+
+    @staticmethod
+    def extract_package_version_from_package_json(content: str, package_name: str) -> Optional[Dict]:
+        """
+        Extrae la versión de un paquete del contenido de package.json
+        
+        Args:
+            content: Contenido del archivo package.json
+            package_name: Nombre del paquete a buscar (ej: '@bancolombia/design-system-web')
+            
+        Returns:
+            Diccionario con versión completa y major, o None
+        """
+        if not content:
+            return None
+        
+        try:
+            # Intentar parsear como JSON
+            package_data = json.loads(content)
+            
+            # Buscar en dependencies y devDependencies
+            for dep_key in ['dependencies', 'devDependencies']:
+                if dep_key in package_data:
+                    deps = package_data[dep_key]
+                    if package_name in deps:
+                        version_str = deps[package_name]
+                        
+                        # Extraer versión semántica (eliminar ^, ~, >=, etc.)
+                        version_match = re.search(r'([0-9]+\.[0-9]+\.[0-9]+)', version_str)
+                        if version_match:
+                            version = version_match.group(1)
+                            major_version = version.split('.')[0]
+                            return {
+                                'full_version': version,
+                                'major_version': major_version
+                            }
+        except json.JSONDecodeError:
+            # Si falla el parseo JSON, intentar con regex
+            pass
+        
+        # Fallback: buscar con regex
+        pattern = rf'"{re.escape(package_name)}"\s*:\s*"[\^~>=<]*([0-9]+\.[0-9]+\.[0-9]+)'
+        match = re.search(pattern, content)
+        if match:
+            version = match.group(1)
+            major_version = version.split('.')[0]
+            return {
+                'full_version': version,
+                'major_version': major_version
+            }
+        
+        return None

{commons_metrics-0.0.19 → commons_metrics-0.0.20}/commons_metrics/database.py

@@ -1,4 +1,6 @@
 import psycopg2
+from .repositories import ComponentRepository
+from .util import Util
 
 class DatabaseConnection:
     """
@@ -37,3 +39,18 @@ class DatabaseConnection:
         """Rolls back pending transactions in case of error"""
         if self.connection and not self.connection.closed:
             self.connection.rollback()
+
+    def get_connection_database_from_secret(secret_name: str, logger: str, aws_region: str) -> ComponentRepository:
+        """
+        Retrieve connection database from AWS secrets manager
+        """
+        secret_json = Util.get_secret_aws(secret_name, logger, aws_region)
+        db_connection = DatabaseConnection()
+        db_connection.connect({
+            'host': secret_json["host"],
+            'port': secret_json["port"],
+            'dbname': secret_json["dbname"],
+            'username': secret_json["username"],
+        'password': secret_json["password"]
+        })
+        return ComponentRepository(db_connection)

commons_metrics-0.0.20/commons_metrics/date_utils.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+from typing import List, Dict
+
+from dateutil import parser
+
+
+class DateUtils:
+    """Utilidades para manejo de fechas y conversiones"""
+    
+    @staticmethod
+    def parse_datetime(date_str: str) -> datetime:
+        """
+        Converts a string in ISO 8601 format to a datetime object.
+        If the string is empty or None, it returns the current date and time with the time zone.
+
+        Args:
+            date_str(str): Date in ISO 8601 format (e.g., "2025-12-02T10:00:00+00:00").
+        Returns:
+            datetime: Datetime object corresponding to the string, or the current date if empty.
+        """
+        if not date_str:
+            return datetime.now().astimezone()
+        return parser.isoparse(date_str)
+
+    @staticmethod
+    def get_hours_difference_from_strings(start_date: str, end_date: str) -> float:
+        """
+        Calculate the difference in hours between two dates given as ISO 8601 strings.
+
+        Args:
+            start_date(str): Start date in ISO 8601 format.
+            end_date(str): End date in ISO 8601 format.
+        Returns:
+            float: Difference in hours (can be negative if end_date < start_date).
+        """
+        start = DateUtils.parse_datetime(start_date)
+        end = DateUtils.parse_datetime(end_date)
+        return DateUtils.get_hours_difference(start, end)
+
+    @staticmethod
+    def get_hours_difference(start_date: datetime, end_date: datetime) -> float:
+        """
+        Calculate the difference in hours between two datetime objects.
+
+        Args:
+            start_date(datetime): Start date.
+            end_date(datetime): End date.
+        Returns:
+            float: Difference in hours (can be negative if end_date < start_date).
+        """
+        return (end_date - start_date).total_seconds() / 3600
+
+    @staticmethod
+    def sort_by_date(list_dicts: List[Dict], date_attribute_name: str) -> List[Dict]:
+        """
+        Sorts a list of dictionaries by a specified date attribute in descending order.
+        The method uses the `parse_datetime` function to convert date strings into datetime objects
+        for accurate sorting.
+
+        Args:
+            list_dicts (List[Dict]): A list of dictionaries containing date attributes.
+            date_attribute_name (str): The key name of the date attribute in each dictionary.
+        Returns:
+            List[Dict]: A new list of dictionaries sorted by the given date attribute in descending order.
+        """
+        return sorted(
+            list_dicts,
+            key=lambda x: DateUtils.parse_datetime(x.get(date_attribute_name)),
+            reverse=True
+        )

commons_metrics-0.0.20/commons_metrics/text_simplifier.py

@@ -0,0 +1,53 @@
+import html
+import json
+import re
+
+
+class TextSimplifier:
+    """Utilidades para limpieza y simplificación de texto"""
+    
+    @staticmethod
+    def compact_data(data: dict) -> str:
+        """
+        Removes keys with empty values (None, "", [], {}) from a dictionary
+        and returns a compact JSON string without unnecessary spaces.
+
+        Args:
+            data(dict): Original dictionary.
+        Returns:
+            str: Compact JSON representation of the filtered dictionary.
+        """
+        data = {k: v for k, v in data.items() if v not in (None, "", [], {})}
+        return json.dumps(data, separators=(",", ":"))
+
+    @staticmethod
+    def clear_text(text: str) -> str:
+        """
+        Cleans text by removing HTML tags, Markdown links,
+        decoding HTML characters, removing escaped quotes, and
+        normalizing spaces.
+
+        Args:
+            text (str): Original text.
+        Returns:
+            str: Cleaned and simplified text.
+        """
+        if not text:
+            return ""
+
+        # Remove HTML tags
+        text = re.sub(r'<[^>]+>', '', text)
+
+        # Replace Markdown links [Text](URLxt
+        text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+
+        # Decode HTML characters (&nbsp;, &lt;, etc.)
+        text = html.unescape(text)
+
+        # Remove escaped quotes
+        text = text.replace('\\"', '"').replace("\\'", "'")
+
+        # Remove line breaks, tabs, and multiple spaces
+        text = re.sub(r'\s+', ' ', text).strip()
+
+        return text

commons_metrics-0.0.20/commons_metrics/variable_finder.py

@@ -0,0 +1,191 @@
+import re
+
+from typing import Optional
+
+
+class VariableFinder:
+    """Utilidades para extraer y buscar variables y códigos en texto y JSON"""
+    
+    @staticmethod
+    def extract_issue_number(pr_body: str):
+        """
+        Extracts an issue number from a pull request body text.
+        Looks for a pattern like '#123' preceded by whitespace.
+
+        Args:
+            pr_body (str): The pull request body text.
+        Returns:
+            Optional[int]: The extracted issue number as an integer, or None if not found.
+        """
+        match = re.search(r"\s+#(\d+)", pr_body or "", re.IGNORECASE)
+        return int(match.group(1)) if match else None
+
+    @staticmethod
+    def get_code(text: str) -> Optional[str]:
+        """
+        Extracts a code matching the pattern 'AW1234567' or 'NU1234567' from a string.
+        The code consists of two uppercase letters followed by seven digits.
+
+        Args:
+            text (str): The input string.
+        Returns:
+            Optional[str]: The extracted code or None if not found.
+        """
+        for tok in text.split('_'):
+            if re.fullmatch(r'[A-Z]{2}\d{7}', tok):
+                return tok
+        return None
+
+    @staticmethod
+    def get_component_name(text: str) -> Optional[str]:
+        """
+        Extracts a component name from a string based on underscore-separated parts.
+        If the last part is 'dxp', returns the two preceding parts joined by underscore.
+        Otherwise, returns the last two parts.
+
+        Args:
+            text (str): The input string.
+        Returns:
+            Optional[str]: The component name or None if not enough parts.
+        """
+        parts = [p for p in text.strip('_').split('_') if p]
+        if len(parts) >= 2:
+            if parts[-1].lower() == "dxp":
+                return f"{parts[-3]}_{parts[-2]}"
+            return '_'.join(parts[-2:])
+        return None
+
+    @staticmethod
+    def get_component_name_from_image(image: str, release_name: str) -> Optional[str]:
+        """
+        Extracts the component name from an image string.
+        If extraction fails, falls back to using release_name.
+
+        Args:
+            image (str): The image string (e.g., 'repo/component:tag').
+            release_name (str): The fallback release name.
+        Returns:
+            Optional[str]: The component name.
+        """
+        try:
+            tag = image.split('/')[-1]
+            repository_name = tag.split(':')[0]
+            return repository_name
+        except Exception:
+            return VariableFinder.get_component_name(release_name)
+
+    @staticmethod
+    def collect_all_variables(json_data, txt_variable_groups):
+        """
+        Collects all variables from a nested JSON structure.
+        Searches for keys named 'variables' and merges them into a single dictionary.
+
+        Args:
+            json_data (dict or list): The JSON data.
+            txt_variable_groups (str): The key name for variable groups.
+        Returns:
+            dict: A dictionary of all variables found.
+        """
+        all_variables = {}
+
+        def loop_through_json(data):
+            if isinstance(data, dict):
+                for key, value in data.items():
+                    if key == 'variables':
+                        all_variables.update(value)
+                    elif key == txt_variable_groups:
+                        if isinstance(value, list):
+                            for group in value:
+                                if isinstance(group, dict) and 'variables' in group:
+                                    all_variables.update(group['variables'])
+                    else:
+                        loop_through_json(value)
+            elif isinstance(data, list):
+                for item in data:
+                    loop_through_json(item)
+
+        loop_through_json(json_data)
+        return all_variables
+
+    @staticmethod
+    def resolve_value(value: str, all_variables: dict, visited=None) -> str:
+        """
+        Resolves variable references in a string recursively.
+        Variables are referenced using the format $(VAR_NAME).
+
+        Args:
+            value (str): The string containing variable references.
+            all_variables (dict): Dictionary of variables and their values.
+            visited (set): Set of visited variables to detect cycles.
+        Returns:
+            str: The resolved string with all references replaced.
+        """
+        if visited is None:
+            visited = set()
+
+        pattern = re.compile(r'\$\(([^)]+)\)')
+        while True:
+            matches = pattern.findall(value)
+            if not matches:
+                break
+            for match in matches:
+                if match in visited:
+                    return f'$(CYCLE:{match})'
+                visited.add(match)
+                replacement = all_variables.get(match, {}).get('value', '')
+                resolved = VariableFinder.resolve_value(replacement, all_variables, visited.copy())
+                value = value.replace(f'$({match})', resolved)
+        return value
+
+    @staticmethod
+    def search_in_json(search_value: str, search_type: str, json_data, is_json_from_azure: bool = False) -> Optional[str]:
+        """
+        Searches for a variable in a nested JSON structure by key or value.
+        Resolves references if found.
+
+        Args:
+            search_value (str): The value to search for.
+            search_type (str): 'clave' to search by key, 'valor' to search by value.
+            json_data (dict or list): The JSON data.
+            is_json_from_azure (bool): Whether the JSON is from Azure (changes key names).
+        Returns:
+            Optional[str]: The resolved value if found, otherwise None.
+        """
+        txt_variable_groups = 'variableGroups' if is_json_from_azure else 'variable_groups'
+        search_value = search_value.lower()
+        all_variables = VariableFinder.collect_all_variables(json_data, txt_variable_groups)
+
+        result_search = all_variables.get(search_value, {}).get('value', '')
+        if result_search and '$(' not in result_search:
+            return result_search
+
+        def recursive_search(data):
+            if isinstance(data, dict):
+                for key, value in data.items():
+                    if key in ['variables', txt_variable_groups]:
+                        if isinstance(value, dict):
+                            for var_key, var_value in value.items():
+                                if search_type == 'clave' and search_value == var_key.lower():
+                                    return VariableFinder.resolve_value(var_value.get('value', ''), all_variables)
+                                elif search_type == 'valor' and search_value == var_value.get('value', '').lower():
+                                    return VariableFinder.resolve_value(var_value.get('value', ''), all_variables)
+                        elif isinstance(value, list):
+                            for item in value:
+                                if isinstance(item, dict) and 'variables' in item:
+                                    for var_key, var_value in item['variables'].items():
+                                        if search_type == 'clave' and search_value == var_key.lower():
+                                            return VariableFinder.resolve_value(var_value.get('value', ''), all_variables)
+                                        elif search_type == 'valor' and search_value == var_value.get('value', '').lower():
+                                            return VariableFinder.resolve_value(var_value.get('value', ''), all_variables)
+                    else:
+                        result = recursive_search(value)
+                        if result:
+                            return result
+            elif isinstance(data, list):
+                for item in data:
+                    result = recursive_search(item)
+                    if result:
+                        return result
+            return None
+
+        return recursive_search(json_data)

{commons_metrics-0.0.19 → commons_metrics-0.0.20}/commons_metrics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commons_metrics
-Version: 0.0.19
+Version: 0.0.20
 Summary: A simple library for basic statistical calculations
 Author: Bancolombia
 Author-email: omar.david.pino@email.com

{commons_metrics-0.0.19 → commons_metrics-0.0.20}/commons_metrics.egg-info/SOURCES.txt

@@ -5,7 +5,6 @@ commons_metrics/__init__.py
 commons_metrics/azure_devops_client.py
 commons_metrics/cache_manager.py
 commons_metrics/commons_repos_client.py
-commons_metrics/connection_database.py
 commons_metrics/database.py
 commons_metrics/date_utils.py
 commons_metrics/github_api_client.py

{commons_metrics-0.0.19 → commons_metrics-0.0.20}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='commons_metrics',
-    version='0.0.19',
+    version='0.0.20',
     description='A simple library for basic statistical calculations',
     #long_description=open('USAGE.md').read(),
     #long_description_content_type='text/markdown',

commons_metrics-0.0.19/commons_metrics/cache_manager.py

@@ -1,71 +0,0 @@
-import requests
-import urllib3
-
-from lib.commons_metrics.commons_metrics.s3_file_manager import S3FileManager
-
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-
-def load_cache_or_fetch(path: str, fetch_fn, clear_cache: bool = False):
-    """
-    Load data from a JSON cache stored in S3 using S3FileManager,
-    or fetch the data and update the cache.
-
-    Args:
-        path (str): Cache key relative to "cache/", e.g. "logs/123.json"
-        fetch_fn (Callable): Function returning JSON-serializable data
-        clear_cache (bool): If True, delete existing cache before fetching
-    Returns:
-        Any: Cached or freshly fetched data
-    """
-    s3 = S3FileManager()
-    key = f"cache/{path}"
-    if clear_cache:
-        try:
-            s3.s3.delete_object(Bucket=s3.bucket, Key=key)
-        except Exception:
-            pass
-    data = s3.load_json(key)
-
-    if data:
-        return data
-
-    data = fetch_fn()
-    s3.save_json(data, key)
-
-    return data
-
-
-def get_data_from_api(url: str, headers: dict, auth_api) -> list:
-    """
-    Sends a GET request to the specified API and returns the JSON response if successful.
-
-    Args:
-        url (str): The API endpoint URL.
-        headers (dict): HTTP headers for the request.
-        auth_api: Authentication object for the request.
-    Returns:
-        list or dict: JSON response from the API if successful, otherwise an empty list.
-    """
-    response = requests.get(url, headers=headers, auth=auth_api, verify=False)
-    if response.ok:
-        return response.json()
-    return []
-
-
-def post_data_to_api(url: str, headers: dict, body: dict, auth_api) -> list:
-    """
-    Sends a POST request to the specified API with the given body and returns the JSON response if successful.
-
-    Args:
-        url (str): The API endpoint URL.
-        headers (dict): HTTP headers for the request.
-        body (dict): Data to send in the POST request.
-        auth_api: Authentication object for the request.
-    Returns:
-        list or dict: JSON response from the API if successful, otherwise an empty list.
-    """
-    response = requests.post(url, headers=headers, auth=auth_api, data=body, verify=False)
-    if response.ok:
-        return response.json()
-    return []

commons_metrics-0.0.19/commons_metrics/commons_repos_client.py

@@ -1,114 +0,0 @@
-"""
-Módulo con funciones compartidas entre clientes de repositorios (GitHub, Azure DevOps)
-"""
-import re
-import json
-from typing import Optional, Dict
-
-
-def extract_package_version_from_pubspec(content: str, package_name: str) -> Optional[Dict]:
-    """
-    Extrae la versión de un paquete del contenido de pubspec.yaml
-    
-    Args:
-        content: Contenido del archivo pubspec.yaml
-        package_name: Nombre del paquete a buscar (ej: 'bds_mobile')
-        
-    Returns:
-        Diccionario con versión completa y major, o None
-    """
-    if not content:
-        return None
-    
-    # Patrones para diferentes formatos de versión (con posibles espacios antes)
-    # IMPORTANTE: debe estar en sección dependencies: para evitar falsos positivos
-    simple_patterns = [
-        # Formato simple: bds_mobile: ^8.127.0 (en la misma línea)
-        rf'^\s*{package_name}\s*:\s*\^?([0-9]+\.[0-9]+\.[0-9]+)',
-        # Formato con >= o ~
-        rf'^\s*{package_name}\s*:\s*>=([0-9]+\.[0-9]+\.[0-9]+)',
-        rf'^\s*{package_name}\s*:\s*~>([0-9]+\.[0-9]+\.[0-9]+)',
-    ]
-    
-    for pattern in simple_patterns:
-        match = re.search(pattern, content, re.MULTILINE)
-        if match:
-            version = match.group(1)
-            major_version = version.split('.')[0]
-            return {
-                'full_version': version,
-                'major_version': major_version
-            }
-    
-    # Formato hosted con artifactory (múltiples variantes)
-    hosted_patterns = [
-        # Patrón 1: hosted simple (una línea)
-        rf'^(\s*){package_name}\s*:\s*$\s*\1\s+hosted:\s*https?://.*?$\s*\1\s+version:\s*["\']?\^?([0-9]+\.[0-9]+\.[0-9]+)',
-        # Patrón 2: hosted con name/url (multilínea)
-        rf'^(\s*){package_name}\s*:\s*$\s*\1\s+hosted:\s*$.*?\s*\1\s+version:\s*["\']?\^?([0-9]+\.[0-9]+\.[0-9]+)',
-    ]
-    
-    for hosted_pattern in hosted_patterns:
-        hosted_match = re.search(hosted_pattern, content, re.MULTILINE | re.DOTALL)
-        if hosted_match:
-            # El último grupo siempre es la versión
-            version = hosted_match.groups()[-1]
-            major_version = version.split('.')[0]
-            return {
-                'full_version': version,
-                'major_version': major_version
-            }
-    
-    return None
-
-
-def extract_package_version_from_package_json(content: str, package_name: str) -> Optional[Dict]:
-    """
-    Extrae la versión de un paquete del contenido de package.json
-    
-    Args:
-        content: Contenido del archivo package.json
-        package_name: Nombre del paquete a buscar (ej: '@bancolombia/design-system-web')
-        
-    Returns:
-        Diccionario con versión completa y major, o None
-    """
-    if not content:
-        return None
-    
-    try:
-        # Intentar parsear como JSON
-        package_data = json.loads(content)
-        
-        # Buscar en dependencies y devDependencies
-        for dep_key in ['dependencies', 'devDependencies']:
-            if dep_key in package_data:
-                deps = package_data[dep_key]
-                if package_name in deps:
-                    version_str = deps[package_name]
-                    
-                    # Extraer versión semántica (eliminar ^, ~, >=, etc.)
-                    version_match = re.search(r'([0-9]+\.[0-9]+\.[0-9]+)', version_str)
-                    if version_match:
-                        version = version_match.group(1)
-                        major_version = version.split('.')[0]
-                        return {
-                            'full_version': version,
-                            'major_version': major_version
-                        }
-    except json.JSONDecodeError:
-        # Si falla el parseo JSON, intentar con regex
-        pass
-    
-    # Fallback: buscar con regex
-    pattern = rf'"{re.escape(package_name)}"\s*:\s*"[\^~>=<]*([0-9]+\.[0-9]+\.[0-9]+)'
-    match = re.search(pattern, content)
-    if match:
-        version = match.group(1)
-        major_version = version.split('.')[0]
-        return {
-            'full_version': version,
-            'major_version': major_version
-        }
-    
-    return None

commons_metrics-0.0.19/commons_metrics/connection_database.py

@@ -1,18 +0,0 @@
-from lib.commons_metrics.commons_metrics import DatabaseConnection, Util, ComponentRepository
-
-
-def get_connection_database_from_secret(secret_name: str, logger: str, aws_region: str) -> ComponentRepository:
-    """
-    Retrieve connection database from AWS secrets manager
-    """
-    secret_json = Util.get_secret_aws(secret_name, logger, aws_region)
-    db_connection = DatabaseConnection()
-    db_connection.connect({
-        'host': secret_json["host"],
-        'port': secret_json["port"],
-        'dbname': secret_json["dbname"],
-        'username': secret_json["username"],
-        'password': secret_json["password"]
-    })
-
-    return ComponentRepository(db_connection)

commons_metrics-0.0.19/commons_metrics/date_utils.py

@@ -1,66 +0,0 @@
-from datetime import datetime
-from typing import List, Dict
-
-from dateutil import parser
-
-
-def parse_datetime(date_str: str) -> datetime:
-    """
-    Converts a string in ISO 8601 format to a datetime object.
-    If the string is empty or None, it returns the current date and time with the time zone.
-
-    Args:
-        date_str(str): Date in ISO 8601 format (e.g., "2025-12-02T10:00:00+00:00").
-    Returns:
-        datetime: Datetime object corresponding to the string, or the current date if empty.
-    """
-    if not date_str:
-        return datetime.now().astimezone()
-    return parser.isoparse(date_str)
-
-
-def get_hours_difference_from_strings(start_date: str, end_date: str) -> float:
-    """
-    Calculate the difference in hours between two dates given as ISO 8601 strings.
-
-    Args:
-        start_date(str): Start date in ISO 8601 format.
-        end_date(str): End date in ISO 8601 format.
-    Returns:
-        float: Difference in hours (can be negative if end_date < start_date).
-    """
-    start = parse_datetime(start_date)
-    end = parse_datetime(end_date)
-    return get_hours_difference(start, end)
-
-
-def get_hours_difference(start_date: datetime, end_date: datetime) -> float:
-    """
-    Calculate the difference in hours between two datetime objects.
-
-    Args:
-        start_date(datetime): Start date.
-        end_date(datetime): End date.
-    Returns:
-        float: Difference in hours (can be negative if end_date < start_date).
-    """
-    return (end_date - start_date).total_seconds() / 3600
-
-
-def sort_by_date(list_dicts: List[Dict], date_attribute_name: str) -> List[Dict]:
-    """
-    Sorts a list of dictionaries by a specified date attribute in descending order.
-    The method uses the `parse_datetime` function to convert date strings into datetime objects
-    for accurate sorting.
-
-    Args:
-        list_dicts (List[Dict]): A list of dictionaries containing date attributes.
-        date_attribute_name (str): The key name of the date attribute in each dictionary.
-    Returns:
-        List[Dict]: A new list of dictionaries sorted by the given date attribute in descending order.
-    """
-    return sorted(
-        list_dicts,
-        key=lambda x: parse_datetime(x.get(date_attribute_name)),
-        reverse=True
-    )

commons_metrics-0.0.19/commons_metrics/text_simplifier.py

@@ -1,48 +0,0 @@
-import html
-import json
-import re
-
-
-def compact_data(data: dict) -> str:
-    """
-    Removes keys with empty values (None, "", [], {}) from a dictionary
-    and returns a compact JSON string without unnecessary spaces.
-
-    Args:
-        data(dict): Original dictionary.
-    Returns:
-        str: Compact JSON representation of the filtered dictionary.
-    """
-    data = {k: v for k, v in data.items() if v not in (None, "", [], {})}
-    return json.dumps(data, separators=(",", ":"))
-
-def clear_text(text: str) -> str:
-    """
-    Cleans text by removing HTML tags, Markdown links,
-    decoding HTML characters, removing escaped quotes, and
-    normalizing spaces.
-
-    Args:
-        text (str): Original text.
-    Returns:
-        str: Cleaned and simplified text.
-    """
-    if not text:
-        return ""
-
-    # Remove HTML tags
-    text = re.sub(r'<[^>]+>', '', text)
-
-    # Replace Markdown links [Text](URLxt
-    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
-
-    # Decode HTML characters (&nbsp;, &lt;, etc.)
-    text = html.unescape(text)
-
-    # Remove escaped quotes
-    text = text.replace('\\"', '"').replace("\\'", "'")
-
-    # Remove line breaks, tabs, and multiple spaces
-    text = re.sub(r'\s+', ' ', text).strip()
-
-    return text

commons_metrics-0.0.19/commons_metrics/variable_finder.py

@@ -1,187 +0,0 @@
-import re
-
-from typing import Optional
-
-
-def extract_issue_number(pr_body: str):
-    """
-    Extracts an issue number from a pull request body text.
-    Looks for a pattern like '#123' preceded by whitespace.
-
-    Args:
-        pr_body (str): The pull request body text.
-    Returns:
-        Optional[int]: The extracted issue number as an integer, or None if not found.
-    """
-    match = re.search(r"\s+#(\d+)", pr_body or "", re.IGNORECASE)
-    return int(match.group(1)) if match else None
-
-
-def get_code(text: str) -> Optional[str]:
-    """
-    Extracts a code matching the pattern 'AW1234567' or 'NU1234567' from a string.
-    The code consists of two uppercase letters followed by seven digits.
-
-    Args:
-        text (str): The input string.
-    Returns:
-        Optional[str]: The extracted code or None if not found.
-    """
-    for tok in text.split('_'):
-        if re.fullmatch(r'[A-Z]{2}\d{7}', tok):
-            return tok
-    return None
-
-
-def get_component_name(text: str) -> Optional[str]:
-    """
-    Extracts a component name from a string based on underscore-separated parts.
-    If the last part is 'dxp', returns the two preceding parts joined by underscore.
-    Otherwise, returns the last two parts.
-
-    Args:
-        text (str): The input string.
-    Returns:
-        Optional[str]: The component name or None if not enough parts.
-    """
-    parts = [p for p in text.strip('_').split('_') if p]
-    if len(parts) >= 2:
-        if parts[-1].lower() == "dxp":
-            return f"{parts[-3]}_{parts[-2]}"
-        return '_'.join(parts[-2:])
-    return None
-
-
-def get_component_name_from_image(image: str, release_name: str) -> Optional[str]:
-    """
-    Extracts the component name from an image string.
-    If extraction fails, falls back to using release_name.
-
-    Args:
-        image (str): The image string (e.g., 'repo/component:tag').
-        release_name (str): The fallback release name.
-    Returns:
-        Optional[str]: The component name.
-    """
-    try:
-        tag = image.split('/')[-1]
-        repository_name = tag.split(':')[0]
-        return repository_name
-    except Exception:
-        return get_component_name(release_name)
-
-
-def collect_all_variables(json_data, txt_variable_groups):
-    """
-    Collects all variables from a nested JSON structure.
-    Searches for keys named 'variables' and merges them into a single dictionary.
-
-    Args:
-        json_data (dict or list): The JSON data.
-        txt_variable_groups (str): The key name for variable groups.
-    Returns:
-        dict: A dictionary of all variables found.
-    """
-    all_variables = {}
-
-    def loop_through_json(data):
-        if isinstance(data, dict):
-            for key, value in data.items():
-                if key == 'variables':
-                    all_variables.update(value)
-                elif key == txt_variable_groups:
-                    if isinstance(value, list):
-                        for group in value:
-                            if isinstance(group, dict) and 'variables' in group:
-                                all_variables.update(group['variables'])
-                else:
-                    loop_through_json(value)
-        elif isinstance(data, list):
-            for item in data:
-                loop_through_json(item)
-
-    loop_through_json(json_data)
-    return all_variables
-
-
-def resolve_value(value: str, all_variables: dict, visited=None) -> str:
-    """
-    Resolves variable references in a string recursively.
-    Variables are referenced using the format $(VAR_NAME).
-
-    Args:
-        value (str): The string containing variable references.
-        all_variables (dict): Dictionary of variables and their values.
-        visited (set): Set of visited variables to detect cycles.
-    Returns:
-        str: The resolved string with all references replaced.
-    """
-    if visited is None:
-        visited = set()
-
-    pattern = re.compile(r'\$\(([^)]+)\)')
-    while True:
-        matches = pattern.findall(value)
-        if not matches:
-            break
-        for match in matches:
-            if match in visited:
-                return f'$(CYCLE:{match})'
-            visited.add(match)
-            replacement = all_variables.get(match, {}).get('value', '')
-            resolved = resolve_value(replacement, all_variables, visited.copy())
-            value = value.replace(f'$({match})', resolved)
-    return value
-
-
-def search_in_json(search_value: str, search_type: str, json_data, is_json_from_azure: bool = False) -> Optional[str]:
-    """
-    Searches for a variable in a nested JSON structure by key or value.
-    Resolves references if found.
-
-    Args:
-        search_value (str): The value to search for.
-        search_type (str): 'clave' to search by key, 'valor' to search by value.
-        json_data (dict or list): The JSON data.
-        is_json_from_azure (bool): Whether the JSON is from Azure (changes key names).
-    Returns:
-        Optional[str]: The resolved value if found, otherwise None.
-    """
-    txt_variable_groups = 'variableGroups' if is_json_from_azure else 'variable_groups'
-    search_value = search_value.lower()
-    all_variables = collect_all_variables(json_data, txt_variable_groups)
-
-    result_search = all_variables.get(search_value, {}).get('value', '')
-    if result_search and '$(' not in result_search:
-        return result_search
-
-    def recursive_search(data):
-        if isinstance(data, dict):
-            for key, value in data.items():
-                if key in ['variables', txt_variable_groups]:
-                    if isinstance(value, dict):
-                        for var_key, var_value in value.items():
-                            if search_type == 'clave' and search_value == var_key.lower():
-                                return resolve_value(var_value.get('value', ''), all_variables)
-                            elif search_type == 'valor' and search_value == var_value.get('value', '').lower():
-                                return resolve_value(var_value.get('value', ''), all_variables)
-                    elif isinstance(value, list):
-                        for item in value:
-                            if isinstance(item, dict) and 'variables' in item:
-                                for var_key, var_value in item['variables'].items():
-                                    if search_type == 'clave' and search_value == var_key.lower():
-                                        return resolve_value(var_value.get('value', ''), all_variables)
-                                    elif search_type == 'valor' and search_value == var_value.get('value', '').lower():
-                                        return resolve_value(var_value.get('value', ''), all_variables)
-                else:
-                    result = recursive_search(value)
-                    if result:
-                        return result
-        elif isinstance(data, list):
-            for item in data:
-                result = recursive_search(item)
-                if result:
-                    return result
-        return None
-
-    return recursive_search(json_data)