afgutils 1.0.6__tar.gz

afgutils-1.0.6/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: afgutils
+Version: 1.0.6
+Summary: Shared support functions
+Author: Araz Heydarov
+Author-email: arazheyderov@gmail.com
+License: copyright
+Requires-Python: >=3.10
+
+Shared support functions

afgutils-1.0.6/afgutils/__init__.py

@@ -0,0 +1,10 @@
+import atexit
+from dotenv import load_dotenv as _load_dotenv
+from .db import DB, sql
+from .email import send_email
+from .s3 import save_to_s3, get_from_s3
+from .utils import *
+from .trandata import *
+
+_load_dotenv()
+atexit.register(DB.close_connections)

afgutils-1.0.6/afgutils/advanceai_util.py

@@ -0,0 +1,21 @@
+from os import getenv
+from datetime import datetime, timezone
+import hashlib
+import json
+import requests
+
+
+def generate_token() -> str:
+    access_key = getenv("advanceai_access_key")
+    secret_key = getenv("advanceai_secret_key")
+    utc_now = datetime.now(timezone.utc)
+    time_epoch_now = int(utc_now.timestamp()*1000)
+    signature = hashlib.sha256(f"{access_key}{secret_key}{time_epoch_now}".encode()).hexdigest()
+
+    token_url = "https://sg-api.advance.ai/openapi/auth/ticket/v1/generate-token"
+    token_body = json.dumps({'accessKey': access_key,
+                             'signature': signature,
+                             'timestamp': time_epoch_now})
+    token_headers = {'Content-Type': 'application/json'}
+    token_response = requests.post(token_url, headers=token_headers, data=token_body)
+    return token_response.json()['data']['token']

afgutils-1.0.6/afgutils/credolab.py

@@ -0,0 +1,68 @@
+from os import getenv
+from afgutils.db import DB
+import requests
+from datetime import datetime
+
+
+class CredoLab:
+    GET_TOKEN_QUERY = """
+            SELECT * FROM credolab.token ORDER BY id DESC LIMIT 1;
+            """
+
+    INSERT_TOKEN_QUERY = """
+            INSERT INTO credolab.token (access_token, token_type, issued, expires, refresh_token)
+            VALUES (?, ?, ?, ?, ?);
+            """
+
+    def __init__(self):
+        self.email = getenv('credolab_user_email')
+        self.password = getenv('credolab_password')
+        self.token = None
+        self.rep_conn = DB.get_connection('rep')
+        self.service_url = getenv('credolab_base_url')
+
+    def get_token(self):
+        if self.token is None:
+            self.token = self._get_token()
+        return self.token
+
+    def _get_token(self):
+        with self.rep_conn.cursor() as cursor:
+            token_details = DB.execute(cursor, self.GET_TOKEN_QUERY, fetch='one')
+
+        if token_details is None or token_details['expires'] < datetime.utcnow():
+            token = self._fetch_token()
+        else:
+            token = token_details['access_token']
+
+        return token
+
+    def _fetch_token(self):
+        url = f'{self.service_url}/v6.0/account/login'
+        payload = {'userEmail': self.email, 'password': self.password}
+        response = requests.post(url, json=payload)
+        if response.status_code != 200:
+            raise Exception(f'Failed to fetch token from CredoLab: {response.text}')
+        token_details = response.json()
+        self._save_token(token_details)
+        return token_details['access_token']
+
+    def _save_token(self, token: dict) -> None:
+
+        with self.rep_conn.cursor() as cursor:
+            DB.execute(cursor, self.INSERT_TOKEN_QUERY,
+                       parameters=(token['access_token'], token['token_type'], token['.issued'],
+                                   token['.expires'], token['refresh_token']))
+        self.rep_conn.commit()
+        return token['access_token']
+
+    def _refresh_token(self, bearer_token: str, refresh_token: str) -> str:
+        url = f'{self.service_url}/v6.0/account/login/refreshToken'
+        payload = {'refreshToken': refresh_token}
+        headers = {'Authorization': f'Bearer {bearer_token}'}
+        response = requests.post(url, json=payload)
+        if response.status_code != 200:
+            raise Exception(f'Failed to refresh token from CredoLab: {response.text}')
+        token_details = response.json()
+        self._save_token(token_details)
+        return token_details['access_token']

afgutils-1.0.6/afgutils/db.py

@@ -0,0 +1,93 @@
+from os import getenv
+import pyodbc
+from pyodbc import Cursor
+
+
+class DB:
+    __connections = {}
+
+    @classmethod
+    def get_connection(cls, db_name: str):
+        if cls.__connections.get(db_name):
+            return cls.__connections.get(db_name)
+        return cls._create_connection(db_name)
+
+    @classmethod
+    def _create_connection(cls, db_name):
+        prefix = db_name
+
+        dsn = getenv(prefix + '_dsn')
+
+        driver = getenv(prefix + '_driver')
+        database = getenv(prefix + '_db')
+        user = getenv(prefix + '_user')
+        password = getenv(prefix + '_pass')
+        server = getenv(prefix + '_host')
+        port = getenv(prefix + '_port')
+
+        if dsn:
+            conn_str = f"DSN={dsn}"
+        elif prefix and driver and driver and user and password and server and port:
+            conn_str = (
+                f"DRIVER={driver};"
+                f"DATABASE={database};"
+                f"UID={user};"
+                f"PWD={password};"
+                f"SERVER={server};"
+                f"PORT={port};"
+            )
+        else:
+            raise ValueError(f"DB configurations could not be found for {db_name}")
+
+        conn = pyodbc.connect(conn_str)
+        cls.__connections[db_name] = conn
+        return conn
+
+    @classmethod
+    def close_connections(cls):
+        # print("Connections are closed")
+        for key in cls.__connections:
+            cls.__connections[key].close()
+        cls.__connections = {}
+
+    @staticmethod
+    def execute(cursor: Cursor, query: str, fetch=None, parameters=None, commit: bool=False):
+        # Execute the query
+        if parameters:
+            cursor.execute(query, parameters)
+        else:
+            cursor.execute(query)
+        if commit:
+            cursor.connection.commit()
+
+        if cursor.rowcount and fetch:
+            # Fetch the rows
+            if fetch == 'all':
+                rows = cursor.fetchall()
+            else:
+                rows = cursor.fetchone()
+
+            index_map = {index: column[0] for index, column in enumerate(cursor.description)}
+            if type(rows) == list:
+                dict_rows = []
+                for row in rows:
+                    new_row = {index_map[index]: value for index, value in enumerate(row)}
+                    dict_rows.append(new_row)
+                return dict_rows
+            else:
+                return {index_map[index]: value for index, value in enumerate(rows)}
+
+
+def sql(sql_name, sql_version, sql_custom_folder=None):
+    if sql_custom_folder:
+        afg_sqls_folder = sql_custom_folder
+    else:
+        afg_sqls_folder = getenv("afg_sqls_folder")
+
+    sql_filename = afg_sqls_folder + sql_name + "/" + sql_name + "." + str(sql_version).zfill(3) + ".sql"
+
+    sql_file = open(sql_filename, "r")
+    sql_text = sql_file.read()
+    sql_file.close()
+
+    return sql_text

afgutils-1.0.6/afgutils/email.py

@@ -0,0 +1,23 @@
+from os import getenv
+import win32com.client as win32
+
+
+def send_email(to: str = None, subject: str = None, message: str = "Empty Message"):
+    # initial check
+    if to is None and getenv('mail_to') is None:
+        raise Exception("to should be passed as parameter or defined as env variable as mail_to")
+    if to is None and getenv('mail_to'):
+        to = getenv('mail_to')
+    outlook = win32.Dispatch('outlook.application')
+    mail = outlook.CreateItem(0)
+    mail.To = to
+    mail.Body = message
+
+    # To send html content
+    # mail.HTMLBody = '<h2>HTML Message body</h2>'
+
+    # To attach a file to the email (optional):
+    # attachment = "Path to the attachment"
+    # mail.Attachments.Add(attachment)
+
+    mail.Send()

afgutils-1.0.6/afgutils/s3.py

@@ -0,0 +1,41 @@
+import boto3
+from os import getenv as _getenv
+
+
+def save_to_s3(s3_key: str, content_body: str, aws_access_key_id=None,
+               aws_secret_access_key=None, aws_region=None, s3_bucket=None):
+    if aws_access_key_id is None: aws_access_key_id = _getenv('aws_access_key_id')
+    if aws_secret_access_key is None: aws_secret_access_key = _getenv('aws_secret_access_key')
+    if aws_region is None: aws_region = _getenv('aws_region')
+    if s3_bucket is None: s3_bucket = _getenv('s3_bucket_risk')
+
+    s3_client = boto3.client('s3'
+                             , aws_access_key_id=aws_access_key_id
+                             , aws_secret_access_key=aws_secret_access_key
+                             , region_name=aws_region)
+    s3_client.put_object(Bucket=s3_bucket
+                         , Body=content_body
+                         , Key=s3_key
+                         )
+
+
+def get_from_s3(s3_key, filename, aws_access_key_id=None, aws_secret_access_key=None, aws_region=None, s3_bucket=None):
+    if aws_access_key_id is None: aws_access_key_id = _getenv('aws_access_key_id')
+    if aws_secret_access_key is None: aws_secret_access_key = _getenv('aws_secret_access_key')
+    if aws_region is None: aws_region = _getenv('aws_region_name')
+    if s3_bucket is None: s3_bucket = _getenv('s3_bucket_lms')
+
+    s3_client = boto3.client(
+        's3',
+        aws_access_key_id=aws_access_key_id,
+        aws_secret_access_key=aws_secret_access_key,
+        region_name=aws_region
+    )
+
+    s3_result = s3_client.download_file(
+        Bucket=s3_bucket,
+        Key=s3_key,
+        Filename=filename
+    )
+
+    return s3_result

afgutils-1.0.6/afgutils/trandata.py

@@ -0,0 +1,134 @@
+import random
+from .db import DB, sql
+from os import getenv
+import requests
+import string
+
+trandata_auth_url = "https://api.trandata.io/account/unauth/v1/login"
+
+
+# VARS INIT
+# trandata_select_token_query = """
+#         SELECT token from kr.token
+#         WHERE created_at > now() - interval '23 HOURS'
+#         ORDER BY created_at desc limit 1
+#     """
+#
+# trandata_insert_token_query = """INSERT INTO kr.token(token) VALUES (?)"""
+# trandata_lms_query = """
+#     SELECT lar.client_id,
+#     c.firstname AS client_firstname,
+#     c.lastname AS client_lastname,
+#     c.date_of_birth AS client_dob,
+#     c.mobile_no AS client_mobile,
+#     c.email_id AS client_email,
+#     ci.document_key AS pan_number,
+#     fd.firstname AS client_father_name,
+#     ad.address_line_one AS client_res_address,
+#     ad.district_name AS client_res_vilage,
+#     ad.district_name AS client_res_city,
+#     'xxx' AS client_res_state,
+#     ad.postal_code AS client_res_pincode,
+#     'vietnam' AS client_res_country,
+#     bad.account_number AS client_bank_acc,
+#     ci.document_key as national_id
+#     FROM f_loan_application_reference lar
+#     LEFT JOIN f_bank_account_detail_associations bada ON bada.entity_id = lar.client_id AND bada.entity_type_enum = 1
+#     LEFT JOIN f_bank_account_details bad ON bad.id = bada.bank_account_detail_id  -- bank account
+#     LEFT JOIN m_client c ON c.id = lar.client_id
+#     LEFT JOIN m_client_identifier ci ON ci.client_id = c.id AND ci.document_type_id = 303
+#     LEFT JOIN f_address_entity ae ON ae.entity_id = c.id AND ae.entity_type_enum =1 AND ae.address_type = 14
+#     LEFT JOIN f_address ad ON ad.id = ae.address_id
+#     LEFT JOIN f_family_details as fd ON fd.client_id = c.id AND fd.relationship_cv_id = 20
+#     WHERE lar.loan_application_reference_no=? LIMIT 1
+# """
+
+# MAIN CODE
+
+# SQLS
+
+
+
+# FUNCS
+
+
+
+
+# Trandata
+def trandata_update_token():
+    """
+        Get log in and parse the Authentication Token.
+        :return: token
+    """
+
+    rep_conn = DB.get_connection('repserv')
+    rep_cursor = rep_conn.cursor()
+
+    username = getenv("trandata_username")
+    password = getenv("trandata_password")
+
+    url = trandata_auth_url
+    payload = "{\n    \"username\": \"" + username + "\",\n    \"password\": \"" + password + "\"\n}"
+    headers = {
+        'Content-Type': 'application/json'
+    }
+
+    response = requests.request("POST", url, headers=headers, data=payload)
+
+    if 300 > response.status_code >= 200:
+        data = response.json()
+        token = data["Data"]["sessionToken"]
+
+        DB.execute(
+            cursor=rep_cursor,
+            query=sql("trandata_insert_token_query", 1),
+            parameters=(token,)
+        )
+
+        rep_cursor.commit()
+        rep_cursor.close()
+
+        return token
+
+    raise ValueError(response.text)
+
+
+def trandata_get_token():
+    rep_conn = DB.get_connection('repserv')
+    rep_cursor = rep_conn.cursor()
+
+    token_res = DB.execute(
+        cursor=rep_cursor,
+        query=sql("trandata_select_token_query", 1),
+        fetch='one'
+    )
+
+    rep_cursor.close()
+
+    if not token_res:
+        token = trandata_update_token()
+
+        return token
+
+    return token_res["token"]
+
+
+# print(trandata_get_token())
+
+def trandata_gen_req_id(appl_ref):
+    ran_text = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
+    result = appl_ref + "_" + ran_text
+    return result
+
+# def trandata_save2boto3(acc_key_id, sec_acc_key, region, response_text, bucket, key):
+#     s3_client = boto3.client(
+#         's3',
+#         aws_access_key_id=acc_key_id,
+#         aws_secret_access_key=sec_acc_key,
+#         region_name=region
+#     )
+#     s3_client.put_object(
+#         Bucket=bucket,
+#         Body=response_text,
+#         Key=key
+#     )

afgutils-1.0.6/afgutils/utils.py

@@ -0,0 +1,132 @@
+import time
+from os import environ
+from .db import DB, sql
+from pandas import json_normalize
+from pandas import DataFrame
+
+session_token_cookie_name = "uwtool_session_token"
+
+
+def print_log(log_line):
+    print(time.strftime('%Y-%m-%d %H:%M:%S'), log_line)
+
+
+def ci(cursor, column_name):
+    column_index_cnt = -1
+    column_index = -1
+    for column in cursor.description:
+        column_index_cnt = column_index_cnt + 1
+        if column[0] == column_name:
+            column_index = column_index_cnt
+            break
+    if column_index == -1:
+        raise SystemExit("ERROR: Column index not found for column: " + column_name)
+    return column_index
+
+
+def nvl(s, d):
+    if s is None:
+        return d
+    else:
+        return s
+
+
+def iif(bool_val, ret_true, ret_false):
+    if bool_val:
+        aaa = ret_true
+    else:
+        aaa = ret_false
+    return aaa
+
+
+def isnullorempty(v):
+    if v is None:
+        return True
+    if type(v) == str:
+        v = v.strip()
+        if len(v) == 0:
+            return True
+    return False
+
+
+def clear_mfv(mfv):
+    if type(mfv) == dict:
+        for i in mfv.keys():
+            mfv[i] = None
+    return mfv
+
+
+def get_username():
+    conn_repserv = DB.get_connection('repserv')
+    cursor_repserv = conn_repserv.cursor()
+
+    username = None
+
+    if 'HTTP_COOKIE' in environ:
+        for cookie in map(str.strip, environ['HTTP_COOKIE'].split(';')):
+            key, value = cookie.split('=')
+            if key == session_token_cookie_name:
+                uwtool_session_token = value
+                result = DB.execute(cursor=cursor_repserv,
+                                    query=sql("find_session", 2),
+                                    fetch='one',
+                                    parameters=uwtool_session_token)
+                if result:  # can be replaced by "if cursor_repserv.rowcount"
+                    username = result['username']
+                    DB.execute(cursor_repserv, sql("update_session", 1), None, (uwtool_session_token, username))
+                    cursor_repserv.commit()
+
+    cursor_repserv.close()
+
+    return username
+
+
+def data_vector_to_sql_insert(data_vector: dict | DataFrame, insert_sql_tpl: str = None,
+                              existing_values: list = None) -> (list, str):
+    column_names_insert_text = ""
+    item_values = []
+
+    # convert data vector into a list
+    if isinstance(data_vector, DataFrame):
+        for column_name in data_vector.columns.tolist():
+            column_names_insert_text = (column_names_insert_text + "," + column_name + "\r\n").replace(".", "_")
+            item_values.append(data_vector.loc[0, column_name])
+
+    elif type(data_vector) is dict:
+        pass
+
+    else:
+        raise TypeError("data_vector_to_sql_insert: data_vector must be a pandas.DataFrame or a dictionary")
+
+    # text-serialize any embedded lists or dictionaries
+    item_values = [str(item_value) if type(item_value) in (list, dict) else item_value for item_value in item_values]
+    # convert any string booleans to actual booleans
+    item_values = [_convert_string_to_boolean(item_value) if type(item_value) is str else item_value for item_value in
+                   item_values]
+
+    # combine existing values with new values
+    if type(existing_values) is list:
+        result_items = existing_values + item_values
+    elif existing_values is None:
+        result_items = item_values
+    else:
+        raise TypeError("data_vector_to_sql_insert: existing_values must be a list or None")
+
+    # generate SQL
+    if type(insert_sql_tpl) is str:
+        result_sql = insert_sql_tpl.format(column_names_insert_text, f"{', ?' * len(item_values)}")
+    elif insert_sql_tpl is None:
+        result_sql = column_names_insert_text
+    else:
+        raise TypeError("data_vector_to_sql_insert: insert_sql_tpl must be a string or None")
+
+    return result_items, result_sql
+
+
+def _convert_string_to_boolean(s: str) -> bool:
+    if s.lower() in ('true', 't', '1', 'y', 'yes'):
+        return True
+    elif s.lower() in ('false', 'f', '0', 'n', 'no'):
+        return False
+    else:
+        return s

afgutils-1.0.6/afgutils.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: afgutils
+Version: 1.0.6
+Summary: Shared support functions
+Author: Araz Heydarov
+Author-email: arazheyderov@gmail.com
+License: copyright
+Requires-Python: >=3.10
+
+Shared support functions

afgutils-1.0.6/afgutils.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+setup.py
+afgutils/__init__.py
+afgutils/advanceai_util.py
+afgutils/credolab.py
+afgutils/db.py
+afgutils/email.py
+afgutils/s3.py
+afgutils/trandata.py
+afgutils/utils.py
+afgutils.egg-info/PKG-INFO
+afgutils.egg-info/SOURCES.txt
+afgutils.egg-info/dependency_links.txt
+afgutils.egg-info/requires.txt
+afgutils.egg-info/top_level.txt

afgutils-1.0.6/afgutils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

afgutils-1.0.6/afgutils.egg-info/requires.txt

@@ -0,0 +1,6 @@
+requests==2.31.0
+pyodbc==4.0.39
+pywin32==306
+python-dotenv==1.0.0
+boto3==1.27.0
+pandas==2.0.3

afgutils-1.0.6/afgutils.egg-info/top_level.txt

@@ -0,0 +1 @@
+afgutils

afgutils-1.0.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

afgutils-1.0.6/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+VERSION = '1.0.6'
+DESCRIPTION = 'Shared support functions'
+LONG_DESCRIPTION = 'Shared support functions'
+
+setup(
+    name="afgutils",
+    version=VERSION,
+    description=DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    author="Araz Heydarov",
+    author_email="arazheyderov@gmail.com",
+    python_requires='>=3.10',
+    license='copyright',
+    packages=find_packages(),
+    install_requires=[
+        'requests==2.31.0',
+        'pyodbc==4.0.39',
+        'pywin32==306',
+        'python-dotenv==1.0.0',
+        'boto3==1.27.0',
+        'pandas==2.0.3']
+)