berryworld 1.0.0.179097__py3-none-any.whl → 1.0.0.197234__py3-none-any.whl

berryworld/__init__.py

@@ -3,14 +3,12 @@ from .handy_mix import HandyMix
 from .transportation_solver import TransportationAlgorithm
 from .allocation_solver import AllocationSolver
 from .pickle_management import PickleManagement
-from .postgres_connection import Postgresql
 from .email_logging import EmailLogging
 from .verify_keys import Verify
-from .credentials import PostgresCredentials, SQLCredentials, BCCredentials, CDSCredentials, SharePointCredentials, \
-    WebServiceCredentials, MicrosoftTeamsCredentials
+from .credentials import SnowflakeCredentials, SQLCredentials, WebServiceCredentials, MicrosoftTeamsCredentials
 from .persistent_storage import PersistentStorage
 from .generate_env import EnvVariables
-from .sharepoint_con import SharepointConnection
+from .sharepoint_con import SharepointConnection, SharepointConn
 from .email_con import EmailConnection
 from .app_logs import AppLogs
 from .app_logs_query import AppLogsQuery
@@ -23,3 +21,6 @@ from .microsoft_teams import MicrosoftTeams
 from .vivantio import Vivantio
 from .teams_logging import TeamsLogging
 from .vivantio_logging import VivantioLogging
+from .snowflake_conn import SnowflakeConn
+from .logging import PythonLogs
+from .sql_connenction import SQLConnection, SQLConnectionPool, SQLPoolEngine

berryworld/cache_data.py

@@ -50,7 +50,7 @@ class CacheManagement:
     def dump_pickle(df, filepath):
         """ Save the data to a filepath
         :param df: DataFrame gathering the data
-        :param path: Path and filename to the file destination
+        :param filepath: Path and filename to the file destination
         """
         pickle_out = open(filepath, 'wb')
         pickle.dump(df, pickle_out)
@@ -59,7 +59,7 @@ class CacheManagement:
     @staticmethod
     def retrieve_pickle(filepath):
         """ Get the data from the indicated filepath
-        :param path: Path and filename to the file destination
+        :param filepath: Path and filename to the file destination
         """
         pickle_in = open(filepath, "rb")
         data_df = pickle.load(pickle_in)
@@ -69,7 +69,7 @@ class CacheManagement:
     @staticmethod
     def remove_pickle(filepath):
         """ Delete a file allocated in filepath
-        :param path: Path and filename to the file destination
+        :param filepath: Path and filename to the file destination
         """
         if os.path.exists(filepath):
             os.remove(filepath)

berryworld/credentials.py

@@ -71,133 +71,6 @@ class SQLCredentials:
             raise ValueError("Variable %s not found" % str(e))
 
 
-class PostgresCredentials:
-    def __init__(self, db_name, server_type=None):
-        if db_name is None:
-            raise ValueError("Please provide a value for db_name")
-        self.db_name = db_name
-        self.server_type = server_type
-
-    def simple_creds(self):
-        if self.server_type is None:
-            raise ValueError("Please provide a value for server_type")
-
-        try:
-            if os.name == 'nt':
-                server_name = os.environ.get(
-                    "POSTGRESQL_" + self.db_name.upper() + '_' + self.server_type.upper() + '_LOCAL_SERVER_NAME')
-            else:
-                server_name = os.environ.get(
-                    "POSTGRESQL_" + self.db_name.upper() + '_' + self.server_type.upper() + '_SERVER_NAME')
-
-            db_name = os.environ.get(
-                "POSTGRESQL_" + self.db_name.upper() + '_' + self.server_type.upper() + '_DB_NAME')
-            user_name = os.environ.get(
-                "POSTGRESQL_" + self.db_name.upper() + '_' + self.server_type.upper() + '_USER_NAME')
-            password = os.environ.get(
-                "POSTGRESQL_" + self.db_name.upper() + '_' + self.server_type.upper() + '_PASSWORD')
-
-            return {'server_name': re.sub(r'(\\)\1*', r'\1', server_name),
-                    'db_name': db_name,
-                    'user_name': user_name,
-                    'password': password}
-        except ValueError as e:
-            raise ValueError("Variable %s not found" % str(e))
-
-
-class BCCredentials:
-    def __init__(self, db_name=None, auth=False):
-        self.db_name = db_name
-        self.auth = auth
-
-    def simple_creds(self):
-        try:
-            if self.auth:
-                scope = os.environ.get("BC_AUTH_SCOPE")
-                client_id = os.environ.get("BC_AUTH_CLIENT_ID")
-                client_secret = os.environ.get("BC_AUTH_CLIENT_SECRET")
-
-                return {'scope': scope,
-                        'client_id': client_id,
-                        'client_secret': client_secret}
-            elif self.db_name is not None:
-                server_type = os.environ.get(f"BC_ENV_SERVER_{self.db_name.upper()}")
-
-                return {'server_type': server_type}
-            else:
-                raise ValueError("Please provide a valid input")
-
-        except ValueError as e:
-            raise ValueError("Variable %s not found" % str(e))
-
-
-class CDSCredentials:
-    def __init__(self, env_name, webhook=False, auth=False):
-        self.env_name = env_name
-        self.webhook = webhook
-        self.auth = auth
-
-    def simple_creds(self):
-        try:
-            if self.auth:
-                scope = os.environ.get("CDS_AUTH_SCOPE")
-                client_id = os.environ.get("CDS_AUTH_CLIENT_ID")
-                client_secret = os.environ.get("CDS_AUTH_CLIENT_SECRET")
-
-                return {'scope': scope,
-                        'client_id': client_id,
-                        'client_secret': client_secret}
-            else:
-                server = os.environ.get(f"CDS_ENV_SERVER_{self.env_name.upper()}")
-                organisation_id = os.environ.get(f"CDS_ENV_ORG_{self.env_name.upper()}")
-                environment_prefix = os.environ.get(f"CDS_ENV_PREFIX_{self.env_name.upper()}")
-                environment_url = os.environ.get(f"CDS_ENV_URL_{self.env_name.upper()}")
-                if self.webhook:
-                    environment_name = os.environ.get(f"CDS_ENV_NAME_{self.env_name.upper()}")
-                else:
-                    environment_name = self.env_name
-
-                return {'server': server,
-                        'environment_name': environment_name,
-                        'organisation_id': organisation_id,
-                        'environment_prefix': environment_prefix,
-                        'environment_url': environment_url}
-
-        except ValueError as e:
-            raise ValueError("Variable %s not found" % str(e))
-
-
-class SharePointCredentials:
-    def __init__(self, site=None):
-        self.site = site
-
-    def simple_creds(self):
-        try:
-            if self.site is None:
-                raise ValueError("Please provide a value for site")
-
-            client_id = os.environ.get(f"SHAREPOINT_CLIENT_ID_{self.site.upper()}")
-            scopes = os.environ.get(f"SHAREPOINT_SCOPES_{self.site.upper()}")
-            organisation_id = os.environ.get(f"SHAREPOINT_ORG_{self.site.upper()}")
-            username = os.environ.get(f"SHAREPOINT_USER_{self.site.upper()}")
-            password = os.environ.get(f"SHAREPOINT_PASSWORD_{self.site.upper()}")
-            site_id = os.environ.get(f"SHAREPOINT_SITE_ID_{self.site.upper()}")
-            site_name = os.environ.get(f"SHAREPOINT_SITE_NAME_{self.site.upper()}")
-            api_version = os.environ.get(f"SHAREPOINT_API_VERSION_{self.site.upper()}")
-
-            return {'client_id': client_id,
-                    'scopes': scopes,
-                    'organisation_id': organisation_id,
-                    'username': username,
-                    'password': password,
-                    'site_id': site_id,
-                    'site_name': site_name,
-                    'api_version': api_version}
-
-        except ValueError as e:
-            raise ValueError("Variable %s not found" % str(e))
-
-
 class WebServiceCredentials:
     def __init__(self, service=None):
         self.service = service
@@ -209,15 +82,18 @@ class WebServiceCredentials:
 
             try:
                 user_name = os.environ.get(f"WEBSERVICE_USER_{self.service.upper()}")
-            except Exception:
+            except Exception as e:
+                print(e)
                 user_name = ''
             try:
                 password = os.environ.get(f"WEBSERVICE_PASSWORD_{self.service.upper()}")
-            except Exception:
+            except Exception as e:
+                print(e)
                 password = ''
             try:
                 access_token = os.environ.get(f"WEBSERVICE_ACCESS_TOKEN_{self.service.upper()}")
-            except Exception:
+            except Exception as e:
+                print(e)
                 access_token = ''
 
             return {'user_name': user_name,
@@ -250,3 +126,23 @@ class MicrosoftTeamsCredentials:
 
         except ValueError as e:
             raise ValueError("Variable %s not found" % str(e))
+
+
+class SnowflakeCredentials:
+    def __init__(self, db_name):
+        if db_name is None:
+            raise ValueError("Please provide a value for db_name")
+        self.db_name = db_name
+
+    def simple_creds(self):
+        try:
+            account = os.environ.get("SNOWFLAKE-" + self.db_name.upper() + '-ACCOUNT')
+            user_name = os.environ.get("SNOWFLAKE-" + self.db_name.upper() + '-USERNAME')
+            password = os.environ.get("SNOWFLAKE-" + self.db_name.upper() + '-PASSWORD')
+
+            return {
+                'account': account,
+                'user_name': user_name,
+                'password': password}
+        except ValueError as e:
+            raise ValueError("Variable %s not found" % str(e))

berryworld/devops.py

@@ -231,7 +231,8 @@ class DevOps:
                 }
             ],
             "commits": [{
-                "comment": f"Adding {environment_name} PowerAutomate properties via API - {run_time}.",
+                "comment": f"Adding {environment_name} PowerAutomate properties via API - {run_time}. "
+                           f"skip-secret-scanning:true",
                 "changes": payload
             }]
         })

berryworld/email_con.py

@@ -1,3 +1,4 @@
+import ast
 import base64
 import json
 import copy
@@ -12,12 +13,49 @@ from msal import ClientApplication
 class EmailConnection:
     """ Tooling to connect to Outlook and manage emails. Use the Graphql Outlook API """
 
-    def __init__(self, client_id, authority, client_secret, email_user, email_password, days_back=10):
-        self.client_id = client_id
-        self.authority = authority
-        self.client_secret = client_secret
-        self.email_user = email_user
-        self.email_password = email_password
+    def __init__(self, email_creds, days_back=10):
+        """ Initialize the class
+        :param email_creds: Dictionary containing the credentials to connect to the email account
+        :param days_back: Number of days back to query emails
+
+        email_creds = {
+            'authority': '',
+            'box': '',
+            'client_id': '',
+            'client_secret': '',
+            'pwd': ''
+        }
+        """
+        try:
+            self.email_creds = ast.literal_eval(email_creds)
+        except Exception as e:
+            raise ValueError(f'Email credentials not properly formatted. ERROR: {e}')
+
+        if 'authority' not in self.email_creds.keys():
+            raise ValueError(f"Authority not provided in email credentials")
+        else:
+            self.authority = self.email_creds['authority']
+
+        if 'client_id' not in self.email_creds.keys():
+            raise ValueError(f"ClientId not provided in email credentials")
+        else:
+            self.client_id = self.email_creds['client_id']
+
+        if 'client_secret' not in self.email_creds.keys():
+            raise ValueError(f"Client Secret not provided in email credentials")
+        else:
+            self.client_secret = self.email_creds['client_secret']
+
+        if 'box' not in self.email_creds.keys():
+            raise ValueError(f"Email Box not provided in email credentials")
+        else:
+            self.email_user = self.email_creds['box']
+
+        if 'pwd' not in self.email_creds.keys():
+            raise ValueError(f"Password not provided in email credentials")
+        else:
+            self.email_password = self.email_creds['pwd']
+
         self.base_url = "https://graph.microsoft.com/v1.0"
         self.headers = self.get_headers()
         self.days_back = days_back

berryworld/email_logging.py

@@ -59,16 +59,24 @@ class EmailLogging:
         :param critical: Indicate whether it should avoid sending successful logs
         :param proposed_solution: Proposed solution to the error message
         """
-        unsuccessful_columns = {'Successful': 0,
-                                'FinishedDate': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
-                                'Section': section,
-                                'ErrorMessage': str(error_message).replace("'", '"'),
-                                'Critical': 1 if critical is True else 0}
-        self.log_df = self.log_df.assign(**unsuccessful_columns)
-        if proposed_solution is not None:
-            self.log_df = self.log_df.assign(**{'ProposedSolution': proposed_solution})
-        self.sql_con.insert(self.log_df, 'Logging', 'PythonLogs', print_sql=self.print_sql)
-        self.failure_type.append(critical)
+        save_failure = True
+        if section is not None:
+            if (('prod' not in str(self.sql_con.server)) | ('prd' not in str(self.sql_con.server))) \
+                    & (('connection' in str(section).lower()) & ('dw' in str(section).lower())):
+                print('Avoiding to report a connection DW error in a non-production environment')
+                save_failure = False
+
+        if save_failure:
+            unsuccessful_columns = {'Successful': 0,
+                                    'FinishedDate': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
+                                    'Section': section,
+                                    'ErrorMessage': str(error_message).replace("'", '"'),
+                                    'Critical': 1 if critical is True else 0}
+            self.log_df = self.log_df.assign(**unsuccessful_columns)
+            if proposed_solution is not None:
+                self.log_df = self.log_df.assign(**{'ProposedSolution': proposed_solution})
+            self.sql_con.insert(self.log_df, 'Logging', 'PythonLogs', print_sql=self.print_sql)
+            self.failure_type.append(critical)
 
     @staticmethod
     def register_failure(email_log, section, error_, solutions=None):

berryworld/generate_env.py

@@ -1,10 +1,203 @@
-from .handy_mix import HandyMix
+import os
+import ast
 import yaml
+import json
+from .handy_mix import HandyMix
+from azure.identity import ClientSecretCredential
+from azure.keyvault.secrets import SecretClient
 
 
 class EnvVariables:
     """ Generate the environmental variables to be used by kubernetes """
 
+    def __init__(self, env=None):
+        """
+        :param env: Environment folder to upload the terraform .tfvars file generated
+        """
+        self.env = env
+
+    def extract_akv_config_from_tf(self, config_path):
+        """ Extract the AKV configuration from the Terraform file
+        :param config_path: Path to the Terraform file
+        """
+        with open(config_path, "r") as f:
+            lines = f.readlines()
+
+        start, end = None, None
+        for idx, line in enumerate(lines):
+            if "akv_config" in line and "=" in line and "{" in line:
+                start = idx + 1
+            if start and "}" in line:
+                end = idx
+                break
+
+        if start is None or end is None:
+            raise ValueError("akv_config block not found in the tf file")
+
+        kv_lines = lines[start:end]
+        config = {}
+        for line in kv_lines:
+            if "=" in line:
+                key, value = line.strip().split("=", 1)
+                key = key.strip()
+                value = value.strip()
+
+                # Use ast.literal_eval to safely evaluate lists or strings
+                try:
+                    parsed_value = ast.literal_eval(value)
+                except:
+                    # fallback if parsing fails
+                    parsed_value = value.strip('"')
+
+                config[key] = parsed_value
+
+        return config
+
+    def get_secret_client(self, config):
+        """ Create a Key Vault client
+        :param config: Dictionary containing Azure Key Vault configuration
+        """
+        tenant_id = config["AZURE-TENANT-ID"]
+        client_id = config["AZURE-CLIENT-ID"]
+        client_secret = config["AZURE-CLIENT-SECRET"]
+        vault_url = f"https://{config['AZURE-KEY-VAULT-NAME']}.vault.azure.net/"
+        credential = ClientSecretCredential(tenant_id, client_id, client_secret)
+
+        return SecretClient(vault_url=vault_url, credential=credential)
+
+    def fetch_secrets_by_tag(self, config):
+        """ Fetch enabled secrets from Azure Key Vault based on tags
+        :param config: Dictionary containing Azure Key Vault configuration
+        """
+        client = self.get_secret_client(config)
+        project_tags = config.get("AZURE-KEY-VAULT-PROJECT-TAGS", [])
+        secrets = {}
+        for prop in client.list_properties_of_secrets():
+            if not prop.enabled:
+                continue
+
+            if prop.tags:
+                if any("project" in key and value in project_tags for key, value in prop.tags.items()):
+                    secret = client.get_secret(prop.name)
+                    key = str(prop.name)
+                    secrets[key] = secret.value
+        return secrets
+
+    def fetch_all_secrets(self, config):
+        """ Fetch all enabled secrets from the Key Vault
+        :param config: Dictionary containing Azure Key Vault configuration
+        """
+        client = self.get_secret_client(config)
+        secrets = {}
+        for prop in client.list_properties_of_secrets():
+            if prop.enabled:
+                secret = client.get_secret(prop.name)
+                secrets[secret.name] = {
+                    "value": secret.value,
+                    "tags": prop.tags or {}
+                }
+        return secrets
+
+    def create_or_update_akv_secret(self, config, name=None, value=None, tags=None, tag_name=None, tag_value=None,
+                                    disable_old=True, secrets_dict=None):
+        """ Create or update a secret / all secrets in Key Vault :
+        :param config: Dictionary containing Azure Key Vault configuration
+        :param name: Name of the secret to be created / updated
+        :param value: Value of the secret to be created / updated
+        :param tags: Dictionary containing Azure Key Vault configuration
+        :param tag_name: Tag name of the secret to be created / updated
+        :param tag_value: Tag value of the secret to be created / updated
+        :param disable_old: Flag if previous version should be disabled
+        :param secrets_dict: Dictionary of all the secrets from AKV
+        """
+        client = self.get_secret_client(config)
+
+        # If secrets_dict is provided, loop through it
+        if secrets_dict is not None:
+            for s_name, s_data in secrets_dict.items():
+                self.create_or_update_akv_secret(
+                    config,
+                    name=s_name,
+                    value=s_data["value"],
+                    tags=s_data.get("tags"),
+                    disable_old=disable_old
+                )
+            return
+
+        if (name is None and value is None) and secrets_dict is None:
+            raise ValueError("Must provide either secrets_dict or both name and value")
+
+        # Check the latest version of the secret
+        latest_secret = None
+        latest_tags = {}
+        try:
+            latest_secret = client.get_secret(name)
+            latest_tags = latest_secret.properties.tags or {}
+        except Exception:
+            pass
+
+        updated_tags = {**latest_tags}
+        if tags is not None:
+            updated_tags.update(tags)
+        elif tag_name is not None and tag_value is not None:
+            updated_tags[tag_name] = tag_value
+
+        # Check if anything changed in the value or tag
+        value_changed = latest_secret is None or latest_secret.value != value
+        tags_changed = updated_tags != latest_tags
+
+        if not value_changed and not tags_changed:
+            print(f"Secret {name} already up to date. Skipping.")
+            return
+
+        # Create new version
+        new_secret = client.set_secret(name, value, tags=updated_tags)
+        new_version = new_secret.properties.version
+        print(f"Secret {name} updated. New version: {new_version}.")
+
+        # Disable previous versions
+        if disable_old:
+            for secret_prop in client.list_properties_of_secret_versions(name):
+                if secret_prop.version != new_version and secret_prop.enabled:
+                    client.update_secret_properties(secret_prop.name, secret_prop.version, enabled=False)
+
+    def generate_akv_env_file(self, config_path=None, env_path=None, fetch_all=False):
+        """ Generate the environment variables file from Azure Key Vault secrets
+        :param config_path: Path to the Terraform configuration file (optional)
+        :param env_path: Path to the destination .env file (optional)
+        :param fetch_all: Flag if all the secrets should be fetched
+        """
+        config = self.extract_akv_config_from_tf(config_path)
+        if fetch_all:
+            secrets = self.fetch_all_secrets(config)
+        else:
+            secrets = self.fetch_secrets_by_tag(config)
+
+        if fetch_all:
+            return secrets
+
+        if not fetch_all:
+            # Create .env file for UnitTest
+            with open(env_path, "w") as f:
+                for key, value in secrets.items():
+                    f.write(f"{key}={value}\n")
+
+            # Create .env file for container apps
+            if os.name != "nt" and self.env is not None:
+                # Linux/Mac: generate terraform .tfvars file
+                tfvars_path = f"./environments/{self.env}/secrets.auto.tfvars.json"
+                os.makedirs(os.path.dirname(tfvars_path), exist_ok=True)
+                with open(tfvars_path, "w") as f:
+                    json.dump({"keyvault_secrets": secrets}, f, indent=2)
+
+    def generate_env_tf(self, config_path='./environments/prod/step01.tf', env_path='.env', fetch_all=False):
+        """ Main function to parse arguments and generate AKV environment variables file.
+        :param config_path: Path to the Terraform configuration file
+        :param env_path: Path to the destination .env file
+        :param fetch_all: Flag if all the secrets should be fetched
+        """
+        self.generate_akv_env_file(config_path=config_path, env_path=env_path, fetch_all=fetch_all)
+
     @staticmethod
     def generate_env_file(yaml_path='./environments/prd1/step01.yaml', env_path='./.env'):
         """ Save the data from the yaml file into a .env file to be used by decouple

berryworld/handy_mix.py

@@ -65,7 +65,21 @@ class HandyMix:
         return result
 
     @staticmethod
-    def likely_match(srs, match_str, n_res=1, threshold=False):
+    def grab_n_elem(n, comp_):
+        max_list = heapq.nlargest(n, comp_)
+        like_matches = np.array([elem in max_list for elem in comp_]).sum()
+        if like_matches > n:
+            list_ = [elem in max_list for elem in comp_]
+            k = 0
+            for elem in list_:
+                if (elem is True) & (k > n - 1):
+                    list_[k] = False
+                k = + 1
+            return list_
+        else:
+            return [elem in max_list for elem in comp_]
+
+    def likely_match(self, srs, match_str, n_res=1, threshold=False):
         """ Look for the more similar element in a Series to the one provided in match_str. If there is a draw,
         It will pick the first matching elements. Threshold only consider the elements if their likelihood is
         greater than that threshold variable
@@ -88,29 +102,15 @@ class HandyMix:
             aux = SequenceMatcher(None, element, match_str)
             comp.append(aux.ratio())
 
-        def grab_n_elem(n, comp):
-            max_list = heapq.nlargest(n, comp)
-            like_matches = np.array([elem in max_list for elem in comp]).sum()
-            if like_matches > n:
-                list_ = [elem in max_list for elem in comp]
-                k = 0
-                for elem in list_:
-                    if (elem is True) & (k > n - 1):
-                        list_[k] = False
-                    k = + 1
-                return list_
-            else:
-                return [elem in max_list for elem in comp]
-
         if threshold:
             # Return n elements above the threshold
             if any(elem >= threshold for elem in comp):
-                return grab_n_elem(n_res, comp)
+                return self.grab_n_elem(n_res, comp)
             else:
                 return [False] * comp.__len__()
         else:
             # Return n elements likely to match
-            return grab_n_elem(n_res, comp)
+            return self.grab_n_elem(n_res, comp)
 
     @staticmethod
     def remove_line_chars(input_text, remove_duplicate_white_spaces=False):
@@ -226,11 +226,15 @@ class HandyMix:
         :param data: DataFrame to transform its integer columns to strings
         :return: DataFrame with its columns translated to strings
         """
-        float_cols = data.columns[data.dtypes == 'float']
+        float_cols = data.select_dtypes(include=['float']).columns
+
         for float_col in float_cols:
-            if data[float_col].dtype == float:
-                if all(['.0' in val for val in data[float_col].loc[~data[float_col].isnull()].astype(str).values]):
-                    data.loc[~data[float_col].isnull(), float_col] = data.loc[
-                        ~data[float_col].isnull(), float_col].astype(str).str.replace('.0', '', regex=True)
+            mask = ~data[float_col].isnull()
+            values = data.loc[mask, float_col]
+
+            data[float_col] = data[float_col].astype(object)
+
+            if ((values % 1) == 0).all():
+                data.loc[mask, float_col] = values.astype(int).astype(str)
 
         return data

berryworld/logging.py

@@ -0,0 +1,31 @@
+
+
+
+class PythonLogs:
+    """ Register the Python Logs """
+    def __init__(self, conn, batch_process):
+        self.conn = conn
+        self.batch_process = batch_process
+        self.batch_log_id = None
+
+    def start(self, log_type):
+        """ Start the Python Log
+        :param log_type: Type of the log
+        """
+        batch_log = self.conn.run_statement(
+            f"EXEC d365bc.spPythonBatchLogInsert @DataType = {self.batch_process}, @LogType = '{log_type}'",
+            commit_as_transaction=False)
+        self.batch_log_id = batch_log['OUTPUT'][0]
+
+    def end(self, batch_log_id=None):
+        """ End the Python Log
+        :param batch_log_id: Batch Log Id
+        """
+        if batch_log_id is None:
+            batch_log_id = self.batch_log_id
+        if batch_log_id is None:
+            raise Exception('Batch Log Id is not set')
+
+        self.conn.run_statement(
+            f"EXEC d365bc.spPythonBatchLogUpdate @BatchLogId = {batch_log_id}",
+            commit_as_transaction=False)

berryworld/microsoft_teams.py

@@ -254,11 +254,11 @@ class MicrosoftTeams:
             vivantio_ticket_id = vivantio_ticket['Id'].values[0]
             display_id = vivantio_ticket['DisplayId'].values[0]
             vivantio_ticket_url = f'https://poupart.flex.vivantio.com/item/Ticket/{vivantio_ticket_id}'
-            html_message = html_message + f'<br><b>Vivantio Ticket Id:</b> {display_id}' + \
-                           f'<br><b>Vivantio Ticket URL:</b> {vivantio_ticket_url}<br>'
+            html_message = html_message + f'<br><b>Vivantio Ticket Id:</b> {display_id}' \
+                                          f'<br><b>Vivantio Ticket URL:</b> {vivantio_ticket_url}<br>'
 
-        html_message = html_message + '<br><b>Error Status:</b> ' + status + f'<br><b>Error Count:</b> {count}' + \
-                       '<br><b>Error Content:</b> <br>' + message
+        html_message = html_message + '<br><b>Error Status:</b> ' + status + f'<br><b>Error Count:</b> {count}' \
+                                                                             f'<br><b>Error Content:</b> <br>' + message
 
         payload = {}
         if importance: