ipulse-shared-core-ftredge 2.7.1__py3-none-any.whl → 2.8.1__py3-none-any.whl

ipulse_shared_core_ftredge/utils/utils_collector_pipelinemon.py

@@ -1,356 +0,0 @@
-# pylint: disable=missing-module-docstring
-# pylint: disable=missing-function-docstring
-# pylint: disable=logging-fstring-interpolation
-# pylint: disable=line-too-long
-# pylint: disable=missing-class-docstring
-# pylint: disable=broad-exception-caught
-import json
-import uuid
-from datetime import datetime, timezone
-from contextlib import contextmanager
-from typing import List
-from ipulse_shared_core_ftredge.enums import LogLevel, TargetLogs
-from ipulse_shared_core_ftredge.utils.logs import  ContextLog
-############################################################################
-##### PIPINEMON Collector for Logs and Statuses of running pipelines #######
-class Pipelinemon:
-    ERROR_START_CODE = LogLevel.ERROR.value
-    WARNING_START_CODE = LogLevel.WARNING.value
-    NOTICE_START_CODE = LogLevel.NOTICE.value
-    SUCCESS_START_CODE = LogLevel.SUCCESS.value
-    INFO_START_CODE = LogLevel.INFO.value
-
-    def __init__(self,  base_context: str, logger, target_logs: TargetLogs = TargetLogs.MIXED,
-                 max_log_field_size:int =10000, max_log_dict_size:float=256 * 1024 * 0.80, max_log_traceback_lines:int = 30):
-
-        self._id = str(uuid.uuid4())
-        self._logs = []
-        self._early_stop = False
-        self._errors_count = 0
-        self._warnings_count = 0
-        self._notices_count = 0
-        self._successes_count = 0
-        self._infos_count = 0
-        self._systems_impacted = []
-        self._by_level_counts = {level.name: 0 for level in LogLevel}
-        self._base_context = base_context
-        self._context_stack = []
-        self._target_logs = target_logs.value
-        self._logger = logger
-        self._max_log_field_size = max_log_field_size
-        self._max_log_dict_size = max_log_dict_size
-        self._max_log_traceback_lines = max_log_traceback_lines
-
-
-    @contextmanager
-    def context(self, context):
-        self.push_context(context)
-        try:
-            yield
-        finally:
-            self.pop_context()
-
-    def push_context(self, context):
-        self._context_stack.append(context)
-
-    def pop_context(self):
-        if self._context_stack:
-            self._context_stack.pop()
-
-    @property
-    def current_context(self):
-        return " >> ".join(self._context_stack)
-
-    @property
-    def base_context(self):
-        return self._base_context
-
-    @property
-    def id(self):
-        return self._id
-
-    @property
-    def systems_impacted(self):
-        return self._systems_impacted
-
-    @systems_impacted.setter
-    def systems_impacted(self, list_of_si: List[str]):
-        self._systems_impacted = list_of_si
-
-    def add_system_impacted(self, system_impacted: str):
-        if self._systems_impacted is None:
-            self._systems_impacted = []
-        self._systems_impacted.append(system_impacted)
-
-    def clear_systems_impacted(self):
-        self._systems_impacted = []
-
-    @property
-    def max_log_dict_size(self):
-        return self._max_log_dict_size
-
-    @max_log_dict_size.setter
-    def max_log_dict_size(self, value):
-        self._max_log_dict_size = value
-
-    @property
-    def max_log_field_size(self):
-        return self._max_log_field_size
-
-    @max_log_field_size.setter
-    def max_log_field_size(self, value):
-        self._max_log_field_size = value
-
-    @property
-    def max_log_traceback_lines(self):
-        return self._max_log_traceback_lines
-
-    @max_log_traceback_lines.setter
-    def max_log_traceback_lines(self, value):
-        self._max_log_traceback_lines = value
-
-    @property
-    def early_stop(self):
-        return self._early_stop
-
-    def set_early_stop(self, max_errors_tolerance:int=0, max_warnings_tolerance:int=0, create_error_log=True, pop_context=False):
-        self._early_stop = True
-        if create_error_log:
-            if pop_context:
-                self.pop_context()
-            if max_errors_tolerance > 0:
-                self.add_log(ContextLog(level=LogLevel.ERROR_PIPELINE_THRESHOLD_REACHED,
-                                        subject="EARLY_STOP",
-                                        description=f"Total MAX_ERRORS_TOLERANCE of {max_errors_tolerance} has been reached."))
-            elif max_warnings_tolerance > 0:
-                self.add_log(ContextLog(level=LogLevel.ERROR_PIPELINE_THRESHOLD_REACHED,
-                                        subject="EARLY_STOP",
-                                        description=f"Total MAX_WARNINGS_TOLERANCE of {max_warnings_tolerance} has been reached."))
-            else:
-                self.add_log(ContextLog(level=LogLevel.ERROR_PIPELINE_THRESHOLD_REACHED,
-                                        subject="EARLY_STOP",
-                                        description="Early stop has been triggered."))
-
-    def reset_early_stop(self):
-        self._early_stop = False
-
-
-    def add_log(self, log: ContextLog ):
-        if (self._target_logs == TargetLogs.SUCCESSES and log.level >=self.NOTICE_START_CODE) or \
-           (self._target_logs == TargetLogs.WARNINGS_AND_ERRORS and log.level.value < self.WARNING_START_CODE):
-            raise ValueError(f"Invalid log level {log.level.name} for Pipelinemon target logs setup: {self._target_logs}")
-        log.base_context = self.base_context
-        log.context = self.current_context if self.current_context else "root"
-        log.collector_id = self.id
-        log.systems_impacted = self.systems_impacted
-        log_dict = log.to_dict(max_field_len=self.max_log_field_size, size_limit=self.max_log_dict_size, max_traceback_lines=self.max_log_traceback_lines)
-        self._logs.append(log_dict)
-        self._update_counts(log_dict)
-
-        if self._logger:
-            # We specifically want to avoid having an ERROR log level for this structured Pipelinemon reporting, to ensure Errors are alerting on Critical Application Services.
-            # A single ERROR log level is usually added at the end of the entire pipeline
-            if log.level.value >= self.WARNING_START_CODE:
-                self._logger.warning(log_dict)
-            else:
-                self._logger.info(log_dict)
-
-    def add_logs(self, logs: List[ContextLog]):
-        for log in logs:
-            self.add_log(log)
-
-    def clear_logs_and_counts(self):
-        self._logs = []
-        self._errors_count = 0
-        self._warnings_count = 0
-        self._notices_count = 0
-        self._successes_count = 0
-        self._infos_count = 0
-        self._by_level_counts = {level.name: 0 for level in LogLevel}
-
-    def clear_logs(self):
-        self._logs = []
-
-    def get_all_logs(self,in_json_format=False):
-        if in_json_format:
-            return json.dumps(self._logs)
-        return self._logs
-
-    def get_logs_for_level(self, level: LogLevel):
-        return [log for log in self._logs if log["level_code"] == level.value]
-
-    def get_logs_by_str_in_context(self, context_substring: str):
-        return [
-            log for log in self._logs
-            if context_substring in log["context"]
-        ]
-
-    def contains_errors(self):
-        return self._errors_count > 0
-
-    def count_errors(self):
-        return self._errors_count
-
-    def contains_warnings_or_errors(self):
-        return self._warnings_count > 0 or self._errors_count > 0
-
-    def count_warnings_and_errors(self):
-        return self._warnings_count + self._errors_count
-
-    def count_warnings(self):
-        return self._warnings_count
-
-    def count_notices(self):
-        return self._notices_count
-
-    def count_successes(self):
-        return self._successes_count
-
-    def count_successes_with_notice(self):
-        return self.count_logs_by_level(LogLevel.SUCCESS_WITH_NOTICES)
-
-    def count_successes_no_notice(self):
-        return self.count_logs_by_level(LogLevel.SUCCESS)
-
-    def count_infos(self):
-        return self._infos_count
-
-    def count_all_logs(self):
-        return len(self._logs)
-
-    def count_logs_by_level(self, level: LogLevel):
-        return self._by_level_counts.get(level.name, 0)
-
-    def _count_logs(self, context_substring: str, exact_match=False, level_code_min=None, level_code_max=None):
-        return sum(
-            1 for log in self._logs
-            if (log["context"] == context_substring if exact_match else context_substring in log["context"]) and
-               (level_code_min is None or log["level_code"] >= level_code_min) and
-               (level_code_max is None or log["level_code"] <= level_code_max)
-        )
-
-    def count_logs_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True)
-
-    def count_logs_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context)
-
-    def count_logs_by_level_for_current_context(self, level: LogLevel):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=level.value, level_code_max=level.value)
-
-    def count_logs_by_level_for_current_and_nested_contexts(self, level: LogLevel):
-        return self._count_logs(self.current_context, level_code_min=level.value, level_code_max=level.value)
-
-    def count_errors_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.ERROR_START_CODE)
-
-    def count_errors_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.ERROR_START_CODE)
-
-    def count_warnings_and_errors_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.WARNING_START_CODE)
-
-    def count_warnings_and_errors_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.WARNING_START_CODE)
-
-    def count_warnings_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.WARNING_START_CODE, level_code_max=self.ERROR_START_CODE - 1)
-
-    def count_warnings_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.WARNING_START_CODE, level_code_max=self.ERROR_START_CODE - 1)
-
-    def count_notices_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.NOTICE_START_CODE, level_code_max=self.WARNING_START_CODE-1)
-
-    def count_notices_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.NOTICE_START_CODE, level_code_max=self.WARNING_START_CODE-1)
-
-    def count_successes_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.SUCCESS_START_CODE, level_code_max=self.NOTICE_START_CODE-1)
-
-    def count_successes_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.SUCCESS_START_CODE, level_code_max=self.NOTICE_START_CODE-1)
-
-    def count_infos_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.INFO_START_CODE, level_code_max=self.SUCCESS_START_CODE-1)
-
-    def count_infos_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.INFO_START_CODE, level_code_max=self.SUCCESS_START_CODE-1)
-    
-    def _update_counts(self, log, remove=False):
-        level_code = log["level_code"]
-        level_name = log["level_name"]
-
-        if remove:
-            if level_code >= self.ERROR_START_CODE:
-                self._errors_count -= 1
-            elif self.WARNING_START_CODE <= level_code < self.ERROR_START_CODE:
-                self._warnings_count -= 1
-            elif self.NOTICE_START_CODE <= level_code < self.WARNING_START_CODE:
-                self._notices_count -= 1
-            elif self.SUCCESS_START_CODE <= level_code < self.NOTICE_START_CODE:
-                self._successes_count -= 1
-            elif self.INFO_START_CODE <= level_code < self.SUCCESS_START_CODE:
-                self._infos_count -= 1
-            self._by_level_counts[level_name] -= 1
-        else:
-            if level_code >= self.ERROR_START_CODE:
-                self._errors_count += 1
-            elif self.WARNING_START_CODE <= level_code < self.ERROR_START_CODE:
-                self._warnings_count += 1
-            elif self.NOTICE_START_CODE <= level_code < self.WARNING_START_CODE:
-                self._notices_count += 1
-            elif self.SUCCESS_START_CODE <= level_code < self.NOTICE_START_CODE:
-                self._successes_count += 1
-            elif self.INFO_START_CODE <= level_code < self.SUCCESS_START_CODE:
-                self._infos_count += 1
-            self._by_level_counts[level_name] += 1
-
-    def generate_file_name(self, file_prefix=None, include_base_context=True):
-        if not file_prefix:
-            file_prefix = self._target_logs
-        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-        if include_base_context:
-            file_name = f"{file_prefix}_{timestamp}_{self.base_context}_len{len(self._logs)}.json"
-        else:
-            file_name = f"{file_prefix}_{timestamp}_len{len(self._logs)}.json"
-
-        return file_name
-
-    def import_logs_from_json(self, json_or_file, logger=None):
-        def log_message(message):
-            if logger:
-                logger.info(message)
-
-        def log_warning(message, exc_info=False):
-            if logger:
-                logger.warning(message, exc_info=exc_info)
-
-        try:
-            if isinstance(json_or_file, str):  # Load from string
-                imported_logs = json.loads(json_or_file)
-            elif hasattr(json_or_file, 'read'):  # Load from file-like object
-                imported_logs = json.load(json_or_file)
-            self.add_logs(imported_logs)
-            log_message("Successfully imported logs from json.")
-        except Exception as e:
-            log_warning(f"Failed to import logs from json: {type(e).__name__} - {str(e)}", exc_info=True)
-
-
-    def generate_final_log_message(self, subjectref: str, total_subjs: int) -> str:
-        return f"""
-            Pipeline for {self.base_context} with pipelinemon.id: {self.id},
-            SUMMARY: Early_Stop= {self.early_stop} ;
-            A)SUCCESSES: {self.count_successes()}/{total_subjs} {subjectref}(s) ; out of which SUCCESSES_WITH_NOTICES: {self.count_successes_with_notice()}/{total_subjs} {subjectref}(s) ;
-            B)NOTICES: {self.count_notices()} ;
-            C)WARNINGS: {self.count_warnings()} ;
-            D)ERRORS: {self.count_errors()} ;
-            E)INFOS: {self.count_infos()} ;
-        """
-
-    def log_final_message(self, subjectref: str, total_subjs: int, generallogger):
-        final_log_message = self.generate_final_log_message(subjectref=subjectref, total_subjs=total_subjs)
-        if self.count_warnings_and_errors() > 0:
-            generallogger.error(final_log_message)
-        else:
-            generallogger.info(final_log_message)

ipulse_shared_core_ftredge/utils/utils_templates_and_schemas.py

@@ -1,151 +0,0 @@
-# pylint: disable=missing-module-docstring
-# pylint: disable=missing-function-docstring
-# pylint: disable=logging-fstring-interpolation
-# pylint: disable=line-too-long
-# pylint: disable=broad-exception-caught
-
-import datetime
-from ipulse_shared_core_ftredge.enums import LogLevel
-from ipulse_shared_core_ftredge.utils.logs import ContextLog
-
-
-def check_format_against_schema_template(data_to_check, schema, dt_ts_to_str=True, check_max_length=True):
-    """Ensure Update dict corresponds to the config schema, ensuring proper formats and lengths."""
-    checked_data = {}
-    warnings_or_error = []  # Group warnings and errors for a given run
-
-    try:
-        # Process updates to conform to the schema
-        for field in schema:
-            field_name = field["name"]
-            field_type = field["type"]
-            mode = field["mode"]
-
-            # Initialize notice to None at the start of each field processing
-            warning = None
-
-            if field_name in data_to_check:
-                value = data_to_check[field_name]
-                if value is None:
-                    if mode == "REQUIRED":
-                        warnings_or_error.append(ContextLog(level=LogLevel.WARNING_FIX_REQUIRED,
-                                                subject=field_name,
-                                                description=f"Required field '{field_name}' is missing in the updates."))
-                        continue
-                else:
-                    # Handle date and timestamp formatting
-                    if field_type == "DATE":
-                        value, warning = handle_date_fields(field_name, value, dt_ts_to_str)
-                    elif field_type == "TIMESTAMP":
-                        value, warning = handle_timestamp_fields(field_name, value, dt_ts_to_str)
-                    elif field_type in ["STRING", "INT64", "FLOAT64", "BOOL"]:
-                        value, warning = handle_type_conversion(field_type, field_name, value)
-
-                    if warning:
-                        warnings_or_error.append(warning)
-
-                    # Check and handle max length restriction
-                    if check_max_length and "max_length" in field:
-                        value, warning = check_and_truncate_length(field_name, value, field["max_length"])
-                        if warning:
-                            warnings_or_error.append(warning)
-
-                    # Only add to the dictionary if value is not None or the field is required
-                    checked_data[field_name] = value
-
-            elif mode == "REQUIRED":
-                warnings_or_error.append(ContextLog(level=LogLevel.WARNING,
-                                              subject=field_name,
-                                              description=f"Required field '{field_name}' is missing in the updates."))
-
-    except Exception as e:
-        warnings_or_error.append(ContextLog(level=LogLevel.ERROR_EXCEPTION,
-                                            e=e,
-                               subject=data_to_check,
-                               description=f"An error occurred during update check: {str(e)}"))
-
-    return checked_data, warnings_or_error
-
-
-
-def handle_date_fields(field_name, value, dt_ts_to_str):
-    """Handles date fields, ensuring they are in the correct format and optionally converts them to string."""
-    if isinstance(value, datetime.date):
-        if dt_ts_to_str:
-            return value.strftime("%Y-%m-%d"), None
-        return value, None
-    elif isinstance(value, str):
-        try:
-            parsed_date = datetime.datetime.strptime(value, "%Y-%m-%d").date()
-            if dt_ts_to_str:
-                return value, None
-            return parsed_date, None
-        except ValueError:
-            return None, ContextLog(level=LogLevel.WARNING_FIX_REQUIRED,
-                                                  subject=field_name,
-                                                   description=f"Expected a DATE in YYYY-MM-DD format but got {value}.")
-    else:
-        return None, ContextLog(level=LogLevel.WARNING_FIX_REQUIRED,
-                                              subject=field_name,
-                                              description= f"Expected a DATE or YYYY-MM-DD str format but got {value} of type {type(value).__name__}.")
-
-
-def handle_timestamp_fields(field_name, value, dt_ts_to_str):
-    """Handles timestamp fields, ensuring they are in the correct format and optionally converts them to ISO format string."""
-    if isinstance(value, datetime.datetime):
-        if dt_ts_to_str:
-            return value.isoformat(), None
-        return value, None
-    elif isinstance(value, str):
-        try:
-            parsed_datetime = datetime.datetime.fromisoformat(value)
-            if dt_ts_to_str:
-                return value, None
-            return parsed_datetime, None
-        except ValueError:
-            return None, ContextLog(level=LogLevel.WARNING_FIX_REQUIRED,
-                                                  subject=field_name,
-                                                  description= f"Expected ISO format TIMESTAMP but got {value}.")
-    else:
-        return None, ContextLog(level=LogLevel.WARNING_FIX_REQUIRED,
-                                              subject=field_name,
-                                              description= f"Expected ISO format TIMESTAMP but got {value} of type {type(value).__name__}.")
-
-
-def check_and_truncate_length(field_name, value, max_length):
-    """Checks and truncates the length of string fields if they exceed the max length."""
-    if isinstance(value, str) and len(value) > max_length:
-        return value[:max_length], ContextLog(level=LogLevel.WARNING_FIX_RECOMMENDED,
-                            subject= field_name,
-                             description= f"Field exceeds max length: {len(value)}/{max_length}. Truncating.")
-
-    return value, None
-
-
-
-def handle_type_conversion(field_type, field_name, value):
-    if field_type == "STRING" and not isinstance(value, str):
-        return str(value), ContextLog(level=LogLevel.WARNING_REVIEW_RECOMMENDED,
-                             subject=field_name,
-                             description= f"Expected STRING but got {value} of type {type(value).__name__}.")
-
-    if field_type == "INT64" and not isinstance(value, int):
-        try:
-            return int(value), None
-        except ValueError:
-            return None, ContextLog(level=LogLevel.WARNING_FIX_REQUIRED,
-                                                subject= field_name,
-                                                description=f"Expected INTEGER, but got {value} of type {type(value).__name__}.")
-    if field_type == "FLOAT64" and not isinstance(value, float):
-        try:
-            return float(value), None
-        except ValueError:
-            return None, ContextLog(level=LogLevel.WARNING_FIX_REQUIRED,
-                                                subject=field_name,
-                                                description=f"Expected FLOAT, but got  {value} of type {type(value).__name__}.")
-    if field_type == "BOOL" and not isinstance(value, bool):
-        return bool(value), ContextLog(level=LogLevel.WARNING_REVIEW_RECOMMENDED,
-                                                subject=field_name,
-                                                description=f"Expected BOOL, but got  {value}. Converting as {bool(value)}.")
-
-    return value, None

ipulse_shared_core_ftredge-2.7.1.dist-info/RECORD

@@ -1,33 +0,0 @@
-ipulse_shared_core_ftredge/__init__.py,sha256=0tmR-zLphsZP6z3uQkF9uMVtry5gYPjiYYzddI_IznM,1222
-ipulse_shared_core_ftredge/enums/__init__.py,sha256=NDv8Vy6_XXRjo0lpTA8SS00KAhb0OtQKJKAvrJhRoK8,1307
-ipulse_shared_core_ftredge/enums/enums_common_utils.py,sha256=O-GE1177xD5tdo7qlKkq38ZoQmnc89uc90KWSDa0FhE,3626
-ipulse_shared_core_ftredge/enums/enums_data_eng.py,sha256=LA4BNTReDXtmLBNQy1z0r4ECOI1LDk2i9MK4XX08ZuU,9960
-ipulse_shared_core_ftredge/enums/enums_logging.py,sha256=N84hR427aJurD1P4XFS1BXuVY-M_rICFsZ03iXR88Zc,4775
-ipulse_shared_core_ftredge/enums/enums_module_fincore.py,sha256=o0sCVjRxr1G_6ZVmvu64VOVIFCkzvJhBOTz8IilkA2s,1621
-ipulse_shared_core_ftredge/enums/enums_modules.py,sha256=8dt6EVYpiyRJ8jaJxz9Wj7_H4ixeX1DK1j4Q0SBayL0,648
-ipulse_shared_core_ftredge/enums/enums_solution_providers.py,sha256=pSmM0JtzR2n0FBJ5Unec0gWMD5zGo6fHwdcCnmGL1oE,497
-ipulse_shared_core_ftredge/enums/pulse_enums.py,sha256=0RjIJbK0pt1Mzo4k_lhhxZL8myEUergQwOY9JOLZIJ4,4716
-ipulse_shared_core_ftredge/models/__init__.py,sha256=MeGH2ZBxkrwldUiWyUaI_TMyfq78tuSwRkN_mEfKD8U,161
-ipulse_shared_core_ftredge/models/organisation.py,sha256=22esRGYuJmKN3papkgozleEmDNJrVwUgIzKp7annvWs,3280
-ipulse_shared_core_ftredge/models/resource_catalog_item.py,sha256=mEGX8AftzrhEHqFVXjr62CuRnXC1vK4z3bHl_XBJodU,4964
-ipulse_shared_core_ftredge/models/user_auth.py,sha256=35HNN7ZW4ZELCqaJrAtoSsVLFAZ1KL2S_VmuzbcEMm4,119
-ipulse_shared_core_ftredge/models/user_profile.py,sha256=D3BB9D6XEv7IVZgsURgf0hWmUZW5rms3uiBXS0ZGLeE,1927
-ipulse_shared_core_ftredge/models/user_profile_update.py,sha256=oKK0XsQDKkgDvjFPhX2XlqEqlKLBQ4AkvPHXEuZbFMY,1712
-ipulse_shared_core_ftredge/models/user_status.py,sha256=8TyRd8tBK9_xb0MPKbI5pn9-lX7ovKbeiuWYYPtIOiw,3202
-ipulse_shared_core_ftredge/utils/__init__.py,sha256=yY4NX-W37xkTWeHOrR-Vni4FNCewaFJ7b9Beejyunyw,887
-ipulse_shared_core_ftredge/utils/utils_cloud.py,sha256=LEsp0L1KfsNqp9nkqxi3TXSuZxXQQenIvagnlJWYytc,2993
-ipulse_shared_core_ftredge/utils/utils_cloud_gcp.py,sha256=5A0qgzFQ2eMe_2uMX4Untxt0G49PX-g-o4XxKENpDQM,22156
-ipulse_shared_core_ftredge/utils/utils_cloud_gcp_with_collectors.py,sha256=Y6_qbZdiVU4kFW3Zk2CjudCUlF1Xrp4m_sLqN7rWCAE,11500
-ipulse_shared_core_ftredge/utils/utils_cloud_with_collectors.py,sha256=vDHt2FrSgj-qmt7Pip-lVbaov8tE3bfQVYKlZ3YcuUE,1612
-ipulse_shared_core_ftredge/utils/utils_collector_pipelinemon.py,sha256=M4Qi1gDxtkPclya64K9JRKWcMhbpcer6LPxDzgpUd04,14995
-ipulse_shared_core_ftredge/utils/utils_common.py,sha256=HTklVthhlMyewR5-qxo6HjMQRokXd-paruoKgENBEKc,8121
-ipulse_shared_core_ftredge/utils/utils_templates_and_schemas.py,sha256=pn2m8IVVjCPKKb9E_SqpUekcwaxyqI3AYn7HjhcVVhM,7489
-ipulse_shared_core_ftredge/utils/logs/__init__.py,sha256=fY6UNr197HYwUDi7uj5fsXw1Ma5gyAFzALxnoDSHFG0,71
-ipulse_shared_core_ftredge/utils/logs/audit_log_firestore.py,sha256=5AwO6NHuOncq65n400eqM8QPrS2EGGaP3Z_6l2rxdBE,261
-ipulse_shared_core_ftredge/utils/logs/context_log.py,sha256=AfDM_R4Xt0nueAMzkwLSPsembseXwSpvnGNv8tbqB1w,8615
-ipulse_shared_core_ftredge/utils/logs/get_logger.py,sha256=u4FTEeNU320s-LJ7-gdhWafWIdWPZsSZl2ymQoc7D3Q,4534
-ipulse_shared_core_ftredge-2.7.1.dist-info/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
-ipulse_shared_core_ftredge-2.7.1.dist-info/METADATA,sha256=_pDlpIXITli6boHmvHKLXg4LvrSVBmphutZcAVKHkU4,556
-ipulse_shared_core_ftredge-2.7.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-ipulse_shared_core_ftredge-2.7.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
-ipulse_shared_core_ftredge-2.7.1.dist-info/RECORD,,