mbu-dev-shared-components 2.4.8__tar.gz → 3.0.1__tar.gz

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbu_dev_shared_components
-Version: 2.4.8
+Version: 3.0.1
 Summary: Shared components to use in RPA projects
 Author-email: MBU <rpa@mbu.aarhus.dk>
 License-Expression: MIT
@@ -22,6 +22,9 @@ Requires-Dist: docx2pdf
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: rawpy
 Provides-Extra: dev
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pytest-json-report; extra == "dev"
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-dependency>=0.5.1; extra == "dev"
 Dynamic: license-file

mbu_dev_shared_components-3.0.1/mbu_dev_shared_components/database/__init__.py

@@ -0,0 +1,4 @@
+# mbu_dev_shared_components/database/__init__.py
+from .connection import RPAConnection
+
+__all__ = ["RPAConnection"]

mbu_dev_shared_components-3.0.1/mbu_dev_shared_components/database/connection.py

@@ -0,0 +1,49 @@
+"""Handles the RPA connection"""
+
+from .constants import Constants
+from .utility import Utility
+from .logging import Log
+
+
+class RPAConnection(
+    Constants,
+    Utility,
+    Log,
+):
+    """Class for running database related """
+    def __init__(self, db_env: str = "PROD", commit: bool | str = False):
+        Constants.__init__(self)
+        Utility.__init__(self)
+        Log.__init__(self)
+        self.db_env = db_env
+        self.commit = commit if isinstance(commit, bool) else commit == "True"
+        self.conn = None
+        self.cursor = None
+
+    def __enter__(self):
+        self.conn = self.connect_to_db(autocommit=False, db_env=self.db_env)
+        self.cursor = self.conn.cursor()
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.commit:
+            print("Commiting transaction...")
+            self.conn.commit()
+        else:
+            print("Rolling back transaction....")
+            self.conn.rollback()
+        print("Closing conection...")
+        self.close()
+        print("Connection closed.")
+
+    def rollback(self):
+        """Rollback transaction on connection if autocommit is not enabled"""
+        if self.autocommit:
+            raise RuntimeError("Cannot rollback: autocommit is enabled.")
+        self.conn.rollback()
+
+    def close(self):
+        """Closes connection"""
+        self.cursor.close()
+        self.conn.close()

mbu_dev_shared_components-3.0.1/mbu_dev_shared_components/database/constants.py

@@ -0,0 +1,54 @@
+"""This module handles generating and fetching constants and credentials from the database"""
+
+from datetime import datetime
+
+from mbu_dev_shared_components.utils.fernet_encryptor import Encryptor
+
+
+class Constants:
+    """Base class for adding and collection constants and credentials"""
+
+    def add_constant(self, constant_name: str, value: str, changed_at: datetime = datetime.now()):
+        query = """
+            INSERT INTO [RPA].[rpa].[Constants] ([name], [value], [changed_at])
+            VALUES (?, ?, ?)
+        """
+        self.execute_query(query, [constant_name, value, changed_at])
+
+    def get_constant(self, constant_name: str) -> dict:
+        query = """
+            SELECT name, value FROM [RPA].[rpa].[Constants] WHERE name = ?
+        """
+        res = self.execute_query(query, [constant_name])
+        if res:
+            name, value = res[0]
+            return {"constant_name": name, "value": value}
+        raise ValueError(f"No constant found with name: {constant_name}")
+
+    def add_credential(self, credential_name: str, username: str, password: str,
+                       changed_at: datetime = datetime.now()):
+        encryptor = Encryptor()
+        encrypted_password = encryptor.encrypt(password)
+        query = """
+            INSERT INTO [RPA].[rpa].[Credentials] ([name], [username], [password], [changed_at])
+            VALUES (?, ?, ?, ?)
+        """
+        self.execute_query(query, [credential_name, username, encrypted_password, changed_at])
+
+    def get_credential(self, credential_name: str) -> dict:
+        encryptor = Encryptor()
+        query = """
+            SELECT username, CAST(password AS varbinary(max))
+            FROM [RPA].[rpa].[Credentials]
+            WHERE name = ?
+        """
+        res = self.execute_query(query, [credential_name])
+        if res:
+            username, encrypted_password = res[0]
+            decrypted_password = encryptor.decrypt(encrypted_password)
+            return {
+                "username": username,
+                "decrypted_password": decrypted_password,
+                "encrypted_password": encrypted_password
+            }
+        raise ValueError(f"No credential found with name {credential_name}")

mbu_dev_shared_components-3.0.1/mbu_dev_shared_components/database/logging.py

@@ -0,0 +1,139 @@
+"""This module handles logging in the RPA database"""
+
+from datetime import datetime
+import time
+import socket
+
+
+class Log:
+    """Base class for handling logging"""
+    def log_event(
+            self,
+            log_db: str,
+            level: str,
+            message: str,
+            context: str,
+    ):
+        """Logs the inputted parameters in """
+        created_at = datetime.now()
+        query = f"""
+            INSERT INTO RPA.{log_db}
+                ([level]
+                ,[message]
+                ,[created_at]
+                ,[context])
+            VALUES
+                (?
+                ,?
+                ,?
+                ,?)
+            """
+
+        params = [level, message, created_at, context]
+        self.execute_query(query=query, params=params)
+
+    def _get_log_event(
+            self,
+            log_db: str,
+            level: str,
+            message: str,
+            context: str,
+    ):
+        query = f"""
+            SELECT
+                ([level]
+                ,[message]
+                ,[created_at]
+                ,[context])
+            FROM
+                RPA.{log_db}
+            WHERE
+                level={level},
+                message={message},
+                context={context}
+            """
+
+        res = self.execute_query(query=query)
+        return res
+
+    def get_latest_log(
+            self,
+            log_db: str,
+    ):
+        """Retrieve latest log message from database"""
+        query = f"""
+            SELECT TOP (1)
+                [level]
+                ,[message]
+                ,[created_at]
+                ,[context]
+            FROM
+                RPA.{log_db}
+            ORDER BY
+                created_at desc
+            """
+
+        res = self.execute_query(query=query)
+        return res
+
+    def _send_heartbeat(
+            self,
+            servicename,
+            status,
+            details
+    ):
+        """Function to send heartbeat to database"""
+        hostname = socket.gethostname()
+        params = {
+            "ServiceName": (str, servicename),
+            "Status": (str, status),
+            "HostName": (str, hostname),
+            "Details": (str, details)
+        }
+        result = self.execute_stored_procedure(
+            stored_procedure='rpa.sp_UpdateHeartbeat',
+            params=params)
+        if result["success"] is not True:
+            print(result["error_message"])
+
+    def log_heartbeat(
+            self,
+            stop: str | bool,
+            servicename: str,
+            heartbeat_interval: int,
+            details: str = "",
+    ):
+        """Function to log heartbeat"""
+        # Update connection such that it autocommits
+        self.conn.autocommit = True  # Sets class attribute
+        if isinstance(stop, str):
+            stop = stop == "True"
+        if not isinstance(heartbeat_interval, int):
+            heartbeat_interval = int(heartbeat_interval)
+        while not stop:
+            status = "RUNNING"
+            self._send_heartbeat(
+                servicename,
+                status,
+                details,
+            )
+            time.sleep(heartbeat_interval)
+        status = "STOPPED"
+        self._send_heartbeat(
+            servicename,
+            status,
+            details,
+        )
+
+    def get_heartbeat(self, service_name: str):
+        """Get hearbeats """
+        query = f"""
+            SELECT
+                *
+            FROM
+                [RPA].[rpa].[ServiceHeartbeat]
+            WHERE
+                ServiceName = '{service_name}'
+        """
+        res = self.execute_query(query)
+        return res

mbu_dev_shared_components-3.0.1/mbu_dev_shared_components/database/utility.py

@@ -0,0 +1,109 @@
+"""This module handles general database connection and calls"""
+
+import os
+import json
+from typing import Dict, Union, Tuple, Any
+from dateutil import parser
+import pyodbc
+
+
+class Utility:
+    """Base class handling general utilities"""
+    def connect_to_db(self, autocommit=True, db_env="PROD") -> pyodbc.Connection:
+        """Establish connection to sql database
+
+        Returns:
+            rpa_conn (pyodbc.Connection): The connection object to the SQL database.
+        """
+        connection_env = self.fetch_env(db_env)
+        rpa_conn_string = os.getenv(connection_env)
+        rpa_conn = pyodbc.connect(rpa_conn_string, autocommit=autocommit)
+        return rpa_conn
+
+    def execute_query(self, query: str, params: list = None) -> pyodbc.Cursor:
+        """Execute SQL query with pyodbc"""
+        params = [] if not params else params
+        is_select = query.strip().upper().startswith('SELECT')
+        try:
+            res = self.cursor.execute(query, params)
+            if is_select:
+                res = self.cursor.fetchall()
+                if len(res) == 0:
+                    print("No results from query")
+                    return None
+                return res
+            else:
+                return None
+        except pyodbc.Error as e:
+            print(e)
+            print(query)
+            raise e
+
+    def fetch_env(self, db_env):
+        """Get env variable based on context, PROD or TEST"""
+        if db_env.upper() == "PROD":
+            connection_env = "DbConnectionString"
+            return connection_env
+        if db_env.upper() == "TEST":
+            connection_env = "DbConnectionStringTest"
+            return connection_env
+
+        raise ValueError(f"arg db_env is {db_env.upper()} but should be 'PROD' or 'TEST'")
+
+    def execute_stored_procedure(self, stored_procedure: str, params: Dict[str, Tuple[type, Any]] | None = None) -> Dict[str, Union[bool, str, Any]]:
+        """
+        Executes a stored procedure with the given parameters.
+
+        Args:
+            connection_string (str): The connection string to connect to the database.
+            stored_procedure (str): The name of the stored procedure to execute.
+            params (Dict[str, Tuple[type, Any]], optional): A dictionary of parameters to pass to the stored procedure.
+                                    Each value should be a tuple of (type, actual_value).
+
+        Returns:
+            Dict[str, Union[bool, str, Any]]: A dictionary containing the success status, an error message (if any),
+                                            number of affected rows, and additional data.
+        """
+        result = {
+            "success": False,
+            "error_message": None,
+        }
+
+        type_mapping = {
+            "str": str,
+            "int": int,
+            "float": float,
+            "datetime": parser.isoparse,
+            "json": lambda x: json.dumps(x, ensure_ascii=False)
+        }
+
+        try:
+            if params:
+                param_placeholders = ', '.join([f"@{key} = ?" for key in params.keys()])
+                param_values = []
+
+                for key, value in params.items():
+                    if isinstance(value, tuple) and len(value) == 2:
+                        value_type, actual_value = value
+                        if value_type in type_mapping:
+                            param_values.append(type_mapping[value_type](actual_value))
+                        else:
+                            param_values.append(actual_value)
+                    else:
+                        raise ValueError("Each parameter value must be a tuple of (type, actual_value).")
+
+                sql = f"EXEC {stored_procedure} {param_placeholders}"
+                rows_updated = self.cursor.execute(sql, tuple(param_values))
+            else:
+                sql = f"EXEC {stored_procedure}"
+                rows_updated = self.cursor.execute(sql)
+            result["success"] = True
+            result["rows_updated"] = rows_updated.rowcount
+        except pyodbc.Error as e:
+            result["error_message"] = f"Database error: {str(e)}"
+        except ValueError as e:
+            result["error_message"] = f"Value error: {str(e)}"
+        except Exception as e:
+            result["error_message"] = f"An unexpected error occurred: {str(e)}"
+
+        return result

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.1}/mbu_dev_shared_components/solteqtand/application/document.py

@@ -126,14 +126,6 @@ class DocumentHandler(HandlerBase):
             first_booking = controls[0]
             first_booking.RightClick(simulateMove=False, waitTime=0)
 
-            # list_bookings_group = self.wait_for_control(
-            #     auto.GroupControl,
-            #     {'AutomationId': 'GroupBoxView'},
-            #     search_depth=13,
-            # )
-            # group_bookings_list = list_bookings_group.GetChildren()[0].GetChildren()[1]
-            # group_bookings_list.RightClick(simulateMove=False, waitTime=0)
-
             pop_up_right_click_menu = self.wait_for_control(
                 auto.MenuControl,
                 {'Name': 'Kontekst'},

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.1}/mbu_dev_shared_components.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbu_dev_shared_components
-Version: 2.4.8
+Version: 3.0.1
 Summary: Shared components to use in RPA projects
 Author-email: MBU <rpa@mbu.aarhus.dk>
 License-Expression: MIT
@@ -22,6 +22,9 @@ Requires-Dist: docx2pdf
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: rawpy
 Provides-Extra: dev
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pytest-json-report; extra == "dev"
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-dependency>=0.5.1; extra == "dev"
 Dynamic: license-file

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.1}/mbu_dev_shared_components.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ mbu_dev_shared_components.egg-info/dependency_links.txt
 mbu_dev_shared_components.egg-info/requires.txt
 mbu_dev_shared_components.egg-info/top_level.txt
 mbu_dev_shared_components/database/__init__.py
+mbu_dev_shared_components/database/connection.py
 mbu_dev_shared_components/database/constants.py
 mbu_dev_shared_components/database/logging.py
 mbu_dev_shared_components/database/utility.py

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.1}/mbu_dev_shared_components.egg-info/requires.txt

@@ -12,5 +12,8 @@ pandas>=2.2.3
 rawpy
 
 [dev]
+pylint
+flake8
+pytest-json-report
 pytest>=7.0
 pytest-dependency>=0.5.1

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.1}/pyproject.toml

@@ -2,13 +2,9 @@
 requires = ["setuptools>=65.0"]
 build-backend = "setuptools.build_meta"
 
-#[tool.setuptools]
-#package-dir = { "" = "." }
-#packages = ["mbu_dev_shared_components"]
-
 [project]
 name = "mbu_dev_shared_components"
-version = "2.4.8"  # Specify the version manually here
+version = "3.0.1"  # Specify the version manually here
 authors = [
   { name="MBU", email="rpa@mbu.aarhus.dk" },
 ]
@@ -37,6 +33,9 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
+  "pylint",
+  "flake8",
+  "pytest-json-report",
   "pytest >= 7.0",
   "pytest-dependency >= 0.5.1"
 ]

mbu_dev_shared_components-2.4.8/mbu_dev_shared_components/database/constants.py

@@ -1,131 +0,0 @@
-"""This module handles generating and fetching constants and credentials from the database"""
-
-import os
-import pyodbc
-from datetime import datetime
-
-from mbu_dev_shared_components.utils.fernet_encryptor import Encryptor
-from mbu_dev_shared_components.database.utility import connect_to_db, execute_query
-
-
-def add_credential(
-        credential_name: str,
-        username: str,
-        password: str,
-        changed_at: datetime = datetime.now(),
-        db_env: str = "PROD"
-):
-    encryptor = Encryptor()
-    encrypted_password = encryptor.encrypt(password)
-
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-
-    query = """
-        INSERT INTO [RPA].[rpa].[Credentials]
-            ([name]
-            ,[username]
-            ,[password]
-            ,[changed_at])
-        VALUES
-            (?
-            ,?
-            ,?
-            ,?)
-        """
-    params = [credential_name, username, encrypted_password, changed_at]
-    execute_query(query=query, cursor=cursor, params=params)
-
-
-def get_credential(
-        credential_name: str,
-        db_env: str = "PROD"
-    ) -> dict:
-    
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-    encryptor = Encryptor()
-
-    query = """
-        SELECT 
-            Username
-            ,cast(Password as varbinary(max))
-        FROM [RPA].[rpa].[Credentials]
-        WHERE
-            name = ?
-        """
-    
-    params = [credential_name]
-
-    res = execute_query(query=query, cursor=cursor, params=params)
-    if res is not None:
-        res = res[0]
-        username = res[0]
-        encrypted_password = res[1]
-
-        decrypted_password = encryptor.decrypt(encrypted_password)
-
-        return  {
-            "username": username, 
-            "decrypted_password": decrypted_password, 
-            "encrypted_password": encrypted_password
-        } 
-    else:
-        print(f"No credential found with name {credential_name}")
-
-def get_constant(
-        constant_name: str,
-        db_env: str = "PROD"
-    ) -> tuple:
-    
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-    encryptor = Encryptor()
-
-    query = """
-        SELECT 
-            name
-            ,value
-        FROM [RPA].[rpa].[Constants]
-        WHERE
-            name = ?
-        """
-    
-    params = [constant_name]
-
-    res = execute_query(query=query, cursor=cursor, params=params)
-    if res is not None:
-
-        returned_constant = res[0]
-        constant_name = returned_constant[0]
-        value = returned_constant[1]
-
-        return {"constant_name": constant_name, "value": value}
-    else:
-        print(f"No constant found with name: {constant_name}")
-
-
-def add_constant(
-        constant_name: str,
-        value: str,
-        changed_at: datetime = datetime.now(),
-        db_env: str = "PROD"
-):
-    query = """
-        INSERT INTO [RPA].[rpa].[Constants]
-            ([name]
-            ,[value]
-            ,[changed_at])
-        VALUES
-            (?
-            ,?
-            ,?)
-        """
-    
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-
-    params = [constant_name, value, changed_at]
-    execute_query(query=query, cursor=cursor, params=params)
-
-

mbu_dev_shared_components-2.4.8/mbu_dev_shared_components/database/logging.py

@@ -1,86 +0,0 @@
-"""This module handles logging in the RPA database"""
-
-from datetime import datetime
-import time
-import os
-import socket
-
-from mbu_dev_shared_components.database.utility import execute_query, connect_to_db, fetch_env
-from mbu_dev_shared_components.utils.db_stored_procedure_executor import execute_stored_procedure
-
-def log_event(
-        log_db: str,
-        level: str, 
-        message: str, 
-        context: str, 
-        db_env="TEST"
-    ):
-    created_at = datetime.now()
-    """Logs the inputted parameters in """
-    query = f"""
-        INSERT INTO RPA.{log_db}
-            ([level]
-            ,[message]
-            ,[created_at]
-            ,[context])
-        VALUES
-            (?
-            ,?
-            ,?
-            ,?)
-        """
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-
-    params = [level, message, created_at, context]
-    execute_query(query=query, cursor=cursor, params=params)
-
-def _send_heartbeat(
-        servicename,
-        status,
-        details,
-        db_env,
-):
-    conn_env = fetch_env(db_env=db_env)
-    conn_str = os.getenv(conn_env)
-    hostname = socket.gethostname()
-    params = {
-        "ServiceName": (str, servicename), 
-        "Status": (str, status), 
-        "HostName": (str, hostname), 
-        "Details": (str, details)
-    }
-    result = execute_stored_procedure(
-        connection_string=conn_str,
-        stored_procedure='rpa.sp_UpdateHeartbeat',
-        params=params)
-    if result["success"] is not True:
-        print(result["error_message"])
-    
-def log_heartbeat(
-        stop: str|bool,
-        servicename: str,
-        heartbeat_interval: int,
-        details: str = "",
-        db_env: str = "PROD"
-    ):
-    if isinstance(stop,str):
-        stop = stop == "True"
-    if not isinstance(heartbeat_interval, int):
-        heartbeat_interval = int(heartbeat_interval)
-    while not stop:
-        status = "RUNNING"
-        _send_heartbeat(
-            servicename,
-            status,
-            details,
-            db_env,
-        )
-        time.sleep(heartbeat_interval)
-    status = "STOPPED"
-    _send_heartbeat(
-        servicename,
-        status,
-        details,
-        db_env,
-    )

mbu_dev_shared_components-2.4.8/mbu_dev_shared_components/database/utility.py

@@ -1,44 +0,0 @@
-"""This module handles general database connection and calls"""
-
-import os
-import pyodbc
-from datetime import datetime
-
-def connect_to_db(autocommit=True, db_env="PROD") -> pyodbc.Connection:
-    """Establish connection to sql database
-
-    Returns:
-        rpa_conn (pyodbc.Connection): The connection object to the SQL database.
-    """
-    connection_env = fetch_env(db_env)
-    rpa_conn_string = os.getenv(connection_env)
-    rpa_conn = pyodbc.connect(rpa_conn_string, autocommit=autocommit)
-    return rpa_conn
-
-def execute_query(query: str, cursor: pyodbc.Cursor, params: list) -> pyodbc.Cursor:
-    is_select = query.strip().upper().startswith('SELECT')
-    try:
-        res = cursor.execute(query, params)
-        if is_select:
-            res = cursor.fetchall()
-            if len(res) == 0:
-                print("No results from query")
-                return None
-            return res
-        else:
-            return None
-    except pyodbc.Error as e:
-        print(e)
-    finally:
-        cursor.close()
-
-
-def fetch_env(db_env):
-    if db_env.upper() == "PROD":
-        connection_env = "DbConnectionString"
-        return connection_env
-    if db_env.upper() == "TEST":
-        connection_env = "DbConnectionStringTest"
-        return connection_env
-    
-    raise ValueError(f"arg db_env is {db_env.upper()} but should be 'PROD' or 'TEST'")