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

berryworld/__init__.py

@@ -2,19 +2,25 @@ from .xml_parser import XMLparser
 from .handy_mix import HandyMix
 from .transportation_solver import TransportationAlgorithm
 from .allocation_solver import AllocationSolver
-from .sql_connection import SQLConnection
 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
+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
-from .sql_connection_polars import SQLConnectionPolars
 from .sql_conn import SQLConn
 from .aks_logs import Logs
+from .devops import DevOps
+from .power_automate import PowerAutomate
+from .logic_apps import LogicApps
+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/allocation_solver.py

@@ -61,8 +61,8 @@ class AllocationSolver:
             # The one with less potential future Ranking Value will be used in the first instance
             ranking_df_gr = ranking_df.loc[(ranking_df[index_prod].isin(max_alloc[index_prod])) & (
                 ranking_df[index_sales].isin(max_alloc[index_sales]))].sort_values(rank_col, ascending=False)[:5]
-            weak_index = ranking_df_gr.groupby(index_prod, as_index=False).sum().sort_values(rank_col, ascending=False)[
-                         -1:]
+            weak_index = ranking_df_gr.groupby(index_prod, as_index=False).sum(
+                numeric_only=True).sort_values(rank_col, ascending=False)[-1:]
 
             # Get production element to be allocated
             max_prod = production_df.loc[production_df[index_prod].isin(weak_index[index_prod])]

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

@@ -7,6 +7,8 @@ load_dotenv(os.path.join(os.getcwd(), '.env'))
 
 class SQLCredentials:
     def __init__(self, db_name, server_type=None, azure=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
         self.azure = azure
@@ -24,9 +26,9 @@ class SQLCredentials:
             else:
                 server_name = os.environ.get("SQL_" + self.db_name.upper() + '_' + self.server_type.upper())
 
-            try:
+            if os.environ.get("SQL_" + self.db_name.upper() + '_DB_NAME_' + self.server_type.upper()) is not None:
                 db_name = os.environ.get("SQL_" + self.db_name.upper() + '_DB_NAME_' + self.server_type.upper())
-            except Exception:
+            else:
                 db_name = os.environ.get("SQL_" + self.db_name.upper() + '_DB_NAME')
 
             user_name = os.environ.get("SQL_" + self.db_name.upper() + '_USER_NAME')
@@ -48,9 +50,9 @@ class SQLCredentials:
             except Exception as e:
                 print(e)
                 dev_ = None
-            try:
+            if os.environ.get("SQL_" + self.db_name.upper() + '_DB_NAME_' + self.server_type.upper()) is not None:
                 db_name = os.environ.get("SQL_" + self.db_name.upper() + '_DB_NAME_' + self.server_type.upper())
-            except Exception:
+            else:
                 db_name = os.environ.get("SQL_" + self.db_name.upper() + '_DB_NAME')
             user_name = os.environ.get("SQL_" + self.db_name.upper() + '_USER_NAME')
             password = os.environ.get("SQL_" + self.db_name.upper() + '_PASSWORD')
@@ -69,156 +71,78 @@ class SQLCredentials:
             raise ValueError("Variable %s not found" % str(e))
 
 
-class PostgresCredentials:
-    def __init__(self, db_name, server_type=None):
-        self.db_name = db_name
-        self.server_type = server_type
+class WebServiceCredentials:
+    def __init__(self, service=None):
+        self.service = service
 
     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))
-
+            if self.service is None:
+                raise ValueError("Please provide a value for site")
 
-class BCCredentials:
-    def __init__(self, db_name=None, auth=False):
-        self.db_name = db_name
-        self.auth = auth
+            try:
+                user_name = os.environ.get(f"WEBSERVICE_USER_{self.service.upper()}")
+            except Exception as e:
+                print(e)
+                user_name = ''
+            try:
+                password = os.environ.get(f"WEBSERVICE_PASSWORD_{self.service.upper()}")
+            except Exception as e:
+                print(e)
+                password = ''
+            try:
+                access_token = os.environ.get(f"WEBSERVICE_ACCESS_TOKEN_{self.service.upper()}")
+            except Exception as e:
+                print(e)
+                access_token = ''
 
-    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")
+            return {'user_name': user_name,
+                    'password': password,
+                    'access_token': access_token}
 
         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
+class MicrosoftTeamsCredentials:
+    def __init__(self, organisation_id=None):
+        self.organisation_id = organisation_id
 
     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))
-
+            if self.organisation_id is None:
+                self.organisation_id = os.environ.get("POUPART_ORGANISATION_ID")
 
-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("MICROSOFT_TEAMS_APP_CLIENT_ID")
+            client_secret = os.environ.get("MICROSOFT_TEAMS_APP_CLIENT_SECRET")
+            username = os.environ.get("MICROSOFT_TEAMS_USERNAME")
+            password = os.environ.get("MICROSOFT_TEAMS_PASSWORD")
 
-            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,
+            return {'organisation_id': self.organisation_id,
+                    'client_id': client_id,
+                    'client_secret': client_secret,
                     'username': username,
-                    'password': password,
-                    'site_id': site_id,
-                    'site_name': site_name,
-                    'api_version': api_version}
+                    'password': password}
 
         except ValueError as e:
             raise ValueError("Variable %s not found" % str(e))
 
 
-class WebServiceCredentials:
-    def __init__(self, service=None):
-        self.service = service
+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:
-            if self.service is None:
-                raise ValueError("Please provide a value for site")
-
-            try:
-                user_name = os.environ.get(f"WEBSERVICE_USER_{self.service.upper()}")
-            except Exception:
-                user_name = ''
-            try:
-                password = os.environ.get(f"WEBSERVICE_PASSWORD_{self.service.upper()}")
-            except Exception:
-                password = ''
-            try:
-                access_token = os.environ.get(f"WEBSERVICE_ACCESS_TOKEN_{self.service.upper()}")
-            except Exception:
-                access_token = ''
-
-            return {'user_name': user_name,
-                    'password': password,
-                    'access_token': access_token}
-
+            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

@@ -0,0 +1,257 @@
+import requests as req
+import json
+import pandas as pd
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+import base64
+import datetime
+
+
+class DevOps:
+    def __init__(self, token=None, api_version=None):
+        """ Connect to Azure DevOps and backup the flows data
+        :param token: Azure DevOps PAT token
+        :param api_version: Azure DevOps API version
+        """
+
+        if token is None:
+            raise Exception('Token is required to connect to DevOps')
+
+        self.headers = {"Content-Type": "application/json",
+                        "Authorization": f"Basic {base64.b64encode(str(f':{token}').encode('utf-8')).decode('utf-8')}"}
+
+        self.session = req.Session()
+        retry = Retry(total=3, status_forcelist=[429, 500, 502, 504], backoff_factor=30)
+        retry.BACKOFF_MAX = 190
+
+        adapter = HTTPAdapter(max_retries=retry)
+        self.session.mount('http://', adapter)
+        self.session.mount('https://', adapter)
+
+        self.base_url = 'https://dev.azure.com/BerryworldGroup'
+
+        if api_version is None:
+            self.api_version = 'api-version=7.0'
+        else:
+            self.api_version = f'api-version={api_version}'
+
+    def session_request(self, method, url, headers=None, data=None, content=False):
+        """ Make a request to Azure DevOps
+        :param method: Request method
+        :param url: Request URL
+        :param headers: Request headers
+        :param data: Request data
+        :param content: Content request
+        """
+
+        if headers is None:
+            headers = self.headers
+
+        if data is None:
+            response = self.session.request(method, url, headers=headers)
+        else:
+            response = self.session.request(method, url, headers=headers, data=data)
+
+        if response.status_code == 204:
+            return pd.DataFrame()
+        elif str(response.status_code).startswith('2'):
+            if content:
+                return response
+
+            response = (json.loads(response.text))
+            if 'value' in response:
+                response_df = pd.DataFrame(response['value'])
+            else:
+                response_df = pd.DataFrame([response])
+
+        else:
+            raise Exception(f'Status: {response.status_code} - {response.text}')
+
+        return response_df
+
+    def list_projects(self):
+        """ List all projects in the DevOps organisation
+        """
+        projects_url = f'{self.base_url}/_apis/projects'
+        projects_df = self.session_request('GET', projects_url)
+
+        return projects_df
+
+    def list_repositories(self, project_name):
+        """ List all repositories in a project
+        :param project_name: DevOps project name
+        """
+        repo_url = f"{self.base_url}/{project_name}/_apis/git/repositories"
+        repo_df = self.session_request('GET', repo_url)
+
+        return repo_df
+
+    def list_repository_items(self, project_name, repo_id, path=None, branch=None):
+        """ List all items in a repository
+        :param project_name: DevOps project name
+        :param repo_id: DevOps repository ID
+        :param path: Path to the repository
+        :param branch: Branch to list
+        """
+        repo_items_url = f"{self.base_url}/{project_name}/_apis/git/repositories/{repo_id}/itemsbatch?" \
+                         f"{self.api_version}"
+
+        if path is None:
+            path = "/"
+
+        if branch is None:
+            branch = "master"
+
+        body = json.dumps({
+            "itemDescriptors": [
+                {
+                    "path": path,
+                    "version": branch,
+                    "versionType": "branch",
+                    "versionOptions": "none",
+                    "recursionLevel": "full"
+                }
+            ],
+            "includeContentMetadata": "true"
+        })
+
+        repo_items_df = self.session_request('POST', repo_items_url, data=body)
+
+        return repo_items_df
+
+    def list_pipeline_releases(self, project_name):
+        """ List all pipeline releases in a project
+        :param project_name: DevOps project name
+        """
+        release_definitions_url = f"https://vsrm.dev.azure.com/BerryworldGroup/{project_name}/_apis/release/definitions"
+        release_definitions_df = self.session_request('GET', release_definitions_url)
+
+        return release_definitions_df
+
+    def list_release_revision(self, project_name, release_id, revision_name=None):
+        """ List all pipeline release revisions
+        :param project_name: DevOps project name
+        :param release_id: DevOps release ID
+        :param revision_name: DevOps release revision name
+        """
+        release_revision_url = f"https://vsrm.dev.azure.com/BerryworldGroup/{project_name}/_apis/release/" \
+                               f"definitions/{release_id}/revisions"
+
+        if revision_name is not None:
+            release_revision_url = f"{release_revision_url}/{revision_name}"
+
+        release_revision_df = self.session_request('GET', release_revision_url)
+
+        return release_revision_df
+
+    def list_pipeline_builds(self, project_name):
+        """ List all pipeline builds in a project
+        :param project_name: DevOps project name
+        """
+        build_definitions_url = f"{self.base_url}/{project_name}/_apis/build/definitions"
+        build_definitions_df = self.session_request('GET', build_definitions_url)
+
+        return build_definitions_df
+
+    def list_build_revision(self, project_name, build_id):
+        """ List all pipeline build revisions
+        :param project_name: DevOps project name
+        :param build_id: DevOps build ID
+        """
+        build_revision_url = f"{self.base_url}/{project_name}/_apis/build/definitions/{build_id}/revisions"
+        build_revision_df = self.session_request('GET', build_revision_url)
+
+        return build_revision_df
+
+    def list_artifact_feeds(self):
+        """ List all artifact feeds
+        """
+        artifact_feeds_url = f"https://feeds.dev.azure.com/BerryworldGroup/_apis/packaging/feeds"
+        artifact_feeds_df = self.session_request('GET', artifact_feeds_url)
+
+        return artifact_feeds_df
+
+    def list_feed_packages(self, feed_id):
+        """ List all packages in a feed
+        :param feed_id: DevOps feed ID
+        """
+        feed_packages_url = f"https://feeds.dev.azure.com/BerryworldGroup/_apis/packaging/feeds/{feed_id}/packages"
+        feed_packages_df = self.session_request('GET', feed_packages_url)
+
+        return feed_packages_df
+
+    def list_package_versions(self, feed_id, package_name):
+        """ List all versions of a package
+        :param feed_id: DevOps feed ID
+        :param package_name: DevOps package name
+        """
+        package_versions_url = f"https://feeds.dev.azure.com/BerryworldGroup/_apis/packaging/feeds/{feed_id}/" \
+                               f"packages/{package_name}/versions"
+        package_versions_df = self.session_request('GET', package_versions_url)
+
+        return package_versions_df
+
+    def get_package_version_content(self, feed_id, package_id, version_id):
+        """ Get the content of a package version
+        :param feed_id: DevOps feed ID
+        :param package_id: DevOps package ID
+        :param version_id: DevOps package version ID
+        """
+        package_content_url = f"https://feeds.dev.azure.com/BerryworldGroup/_apis/packaging/feeds/{feed_id}/" \
+                              f"packages/{package_id}/versions/{version_id}"
+        package_content_df = self.session_request('GET', package_content_url)
+
+        return package_content_df
+
+    def create_repo_files(self, project_name, repo_id, environment_name, payload, branch=None):
+        """ Create files in a repository
+        :param project_name: DevOps project name
+        :param repo_id: DevOps repository ID
+        :param environment_name: Environment name
+        :param payload: Payload to create the files
+        :param branch: Branch to create the files
+        """
+        commits_url = f"{self.base_url}/{project_name}/_apis/git/repositories/{repo_id}/" \
+                      f"commits?{self.api_version}"
+        commits_df = self.session_request("GET", commits_url)
+        if commits_df.shape[0] > 0:
+            last_commit_id = commits_df['commitId'][0]
+        else:
+            last_commit_id = '0000000000000000000000000000000000000000'
+
+        if branch is None:
+            branch = "refs/heads/master"
+
+        run_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        repo_payload = json.dumps({
+            "refUpdates": [
+                {
+                    "name": branch,
+                    "oldObjectId": last_commit_id
+                }
+            ],
+            "commits": [{
+                "comment": f"Adding {environment_name} PowerAutomate properties via API - {run_time}. "
+                           f"skip-secret-scanning:true",
+                "changes": payload
+            }]
+        })
+
+        repo_pushes_url = f"{self.base_url}/{project_name}/_apis/git/repositories/{repo_id}/pushes?{self.api_version}"
+
+        create_repo_files = self.session_request("POST", repo_pushes_url, data=repo_payload)
+
+        return create_repo_files
+
+    def get_file_content(self, project_name, repo_id, file_path):
+        """ Get the content of a file in a repository
+        :param project_name: DevOps project name
+        :param repo_id: DevOps repository ID
+        :param file_path: Path to the file
+        """
+        file_content_url = f"{self.base_url}/{project_name}/_apis/git/repositories/{repo_id}/items?" \
+                           f"scopePath={file_path}&includeContent=True"
+
+        file_content = self.session_request("GET", file_content_url, content=True)
+
+        return file_content

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
@@ -267,20 +305,22 @@ class EmailConnection:
             response = requests.get(url=base_url, headers=header)
             json_resp = response.json()
 
+            if 'value' not in json_resp.keys():
+                return False
             emails_df = pd.DataFrame(json_resp['value'])
             if emails_df.shape[0] > 0:
                 emails_df = emails_df.loc[emails_df['isRead'] == False]
             return emails_df.shape[0] != 0
 
-        except Exception:
-            print(traceback.format_exc())
-            raise Exception("An unknown error have happened")
+        except Exception as e:
+            print(e)
 
     @staticmethod
     def get_mimetype(file_path):
+        """ Get the mimetype of the file to be attached to the email
+        :param file_path: Path of the file to be attached
+        """
         # Get mimetype
-        mimetype = None
-        extension = None
         if ('.jpg' in file_path) | ('.jpeg' in file_path):
             mimetype = "image/jpeg"
             extension = '.jpeg'
@@ -308,5 +348,10 @@ class EmailConnection:
         elif '.xlsx' in file_path:
             mimetype = "application/vnd.ms-excel"
             extension = '.xlsx'
+        elif '.html' in file_path:
+            mimetype = "application/vnd.ms-excel"
+            extension = 'text/html'
+        else:
+            raise Exception('File mime type not found')
 
         return mimetype, extension