db-analytics-tools 0.2__tar.gz → 0.2.1__tar.gz

{db_analytics_tools-0.2 → db_analytics_tools-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: db_analytics_tools
-Version: 0.2
+Version: 0.2.1
 Summary: Databases Tools for Data Analytics
 Home-page: https://joekakone.github.io/db-analytics-tools
 Download-URL: https://github.com/joekakone/db-analytics-tools
@@ -22,6 +22,7 @@ Requires-Dist: streamlit>=1.32.2
 Requires-Dist: matplotlib>=3.4.3
 Requires-Dist: statsmodels>=0.13.5
 Requires-Dist: python-crontab>=3.1.0
+Requires-Dist: apache-airflow>=3.1.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{db_analytics_tools-0.2 → db_analytics_tools-0.2.1}/db_analytics_tools/__init__.py

@@ -7,4 +7,4 @@
 
 from .utils import Client
 
-__version__ = "0.2"
+__version__ = "0.2.1"

{db_analytics_tools-0.2 → db_analytics_tools-0.2.1}/db_analytics_tools/airflow.py

@@ -6,14 +6,27 @@
     This module provides a class for interacting with the Apache Airflow REST API.
 """
 
-import urllib
-import datetime
-import json
+#####################################################################################################################################
+# Hide
 import os
+import sys
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir in sys.path:
+    sys.path.remove(current_dir)
+#####################################################################################################################################
+
+
+import json
+import datetime
+import urllib
 
+import pandas as pd
 import requests
 from requests.auth import HTTPBasicAuth
-import pandas as pd
+from airflow.providers.common.sql.hooks.sql import DbApiHook
+from airflow.exceptions import AirflowNotFoundException
+
+import db_analytics_tools as db
 
 
 class AirflowRESTAPIV1:
@@ -403,6 +416,41 @@ class AirflowRESTAPI:
         return response
 
 
+def create_client_from_airflow(airflow_conn_id):
+    """
+    Creates a database client using connection details from Airflow.
+    param airflow_conn_id: Airflow connection ID.
+    return: Database client instance.
+    """
+    # Retrieve connection from Airflow
+    try:
+        conn_hook = DbApiHook.get_connection(conn_id=airflow_conn_id)
+    except AirflowNotFoundException as e:
+        raise AirflowNotFoundException(f"Connection ID '{airflow_conn_id}' not found in Airflow: {e}")
+    except Exception as e:
+        raise Exception(f"Error retrieving connection '{airflow_conn_id}': {e}")
+    
+    # Extract connection parameters
+    host = conn_hook.host
+    port = conn_hook.port
+    schema = conn_hook.schema
+    login = conn_hook.login
+    password = conn_hook.password
+    conn_type = conn_hook.conn_type
+    
+    # Create a database client
+    client = db.Client(
+        host=host,
+        port=port,
+        database=schema,
+        username=login,
+        password=password,
+        engine=conn_type
+    )
+    
+    return client
+
+    
 def fetch_data(query, connection_id, output_file, html_file):
     """
     Fetches data from a database and saves it to a CSV file and an HTML file.

db_analytics_tools-0.2.1/db_analytics_tools/mail.py

@@ -0,0 +1,218 @@
+"""
+Module for generating HTML email content for ETL job status updates.
+"""
+
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.utils import formataddr, parseaddr
+from typing import Union, List
+
+
+class MailSender:
+    """
+    Class to handle secure email sending using SMTP with context management.
+    """
+    def __init__(
+        self, 
+        email_host: str, 
+        email_port: int, 
+        email_user: str, 
+        email_password: str, 
+        email_use_tls: bool = True, 
+        email_use_ssl: bool = False, 
+        email_from: str = None
+    ):
+        """
+        Initialize the MailSender instance.
+
+        :param email_host: The SMTP server host address.
+        :param email_port: The port number for the SMTP server.
+        :param email_user: The username/email for SMTP authentication.
+        :param email_password: The password/app password for SMTP authentication.
+        :param email_use_tls: Flag to enable Transport Layer Security (TLS).
+        :param email_use_ssl: Flag to enable Secure Sockets Layer (SSL).
+        :param email_from: Optional custom sender identity string (e.g., "Name <email@domain.com>").
+        """
+        self.email_host = email_host
+        self.email_port = int(email_port)
+        self.email_user = email_user
+        self.email_password = email_password
+        self.email_use_tls = email_use_tls
+        self.email_use_ssl = email_use_ssl
+        
+        # Parse friendly name and email address from the custom sender configuration
+        self.email_sender_name, self.email_sender_address = parseaddr(email_from)
+        
+        if not self.email_sender_address:
+            self.email_sender_address = email_user
+            
+        self.session = None
+    
+    def __enter__(self):
+        """
+        Establish an authenticated SMTP session when entering the 'with' context block.
+
+        :return: The initialized MailSender instance.
+        """
+        print(f"Setting up the mail session {self.email_host}:{self.email_port}...")
+        
+        if self.email_use_ssl:
+            self.session = smtplib.SMTP_SSL(self.email_host, self.email_port)
+        else:
+            self.session = smtplib.SMTP(self.email_host, self.email_port)
+        
+        if self.email_use_tls:
+            self.session.starttls()
+        
+        self.session.login(self.email_user, self.email_password)
+        print("Mail session launched and authenticated...")
+        
+        return self
+    
+    def _to_list(self, addresses: Union[str, List[str]]) -> List[str]:
+        """
+        Helper method to normalize single string email addresses or lists into a list.
+        """
+        if not addresses:
+            return []
+        if isinstance(addresses, str):
+            return [addr.strip() for addr in addresses.split(',') if addr.strip()]
+        return [addr.strip() for addr in addresses if addr.strip()]
+
+    def send_mail(
+        self, 
+        receiver_address: Union[str, List[str]], 
+        subject: str, 
+        body_html: str, 
+        attachments: list = None, 
+        cc_addresses: Union[str, List[str]] = None, 
+        bcc_addresses: Union[str, List[str]] = None
+    ):
+        """
+        Construct and send an HTML email message, with optional file attachments.
+
+        :param receiver_address: The email address(es) of the primary recipient(s). Can be a string or list.
+        :param subject: The subject line of the email.
+        :param body_html: The HTML-formatted body content of the email.
+        :param attachments: Optional list of MIME base instances to append to the email.
+        :param cc_addresses: Optional email address(es) to include in the carbon copy (CC).
+        :param bcc_addresses: Optional email address(es) to include in the blind carbon copy (BCC).
+        """
+        if not self.session:
+            raise RuntimeError("SMTP session is not active. Use the 'with' block context.")
+        
+        # Normalize all inputs into clean lists of strings
+        to_list = self._to_list(receiver_address)
+        cc_list = self._to_list(cc_addresses)
+        bcc_list = self._to_list(bcc_addresses)
+
+        if not to_list:
+            raise ValueError("At least one primary receiver_address must be provided.")
+
+        # Setup the MIME multipart message container
+        message = MIMEMultipart()
+        message['From'] = formataddr((self.email_sender_name, self.email_sender_address))
+        message['To'] = ', '.join(to_list)
+        
+        if cc_list:
+            message['Cc'] = ', '.join(cc_list)
+        if bcc_list:
+            message['Bcc'] = ', '.join(bcc_list)
+            
+        message['Subject'] = subject
+        
+        # Process and append any attached files
+        if attachments:
+            for attachment in attachments:
+                message.attach(attachment)
+
+        # Attach the primary HTML body content
+        message.attach(MIMEText(body_html, 'html'))
+        text = message.as_string()
+
+        # SMTP sendmail requires a flat list of all envelope recipients (To + CC + BCC)
+        all_recipients = to_list + cc_list + bcc_list
+
+        self.session.sendmail(self.email_sender_address, all_recipients, text)
+        print(f'Mail Sent to {message["To"]} with subject "{subject}".')
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Gracefully terminate the SMTP session when exiting the 'with' context block.
+        """
+        if self.session:
+            self.session.quit()
+            print("Mail session closed.")
+
+
+##################################################################################################
+## CONSTANTS
+##################################################################################################
+MAIL_CONTENT = """
+<!DOCTYPE html>
+<html>
+<head>
+    <style>
+        table {{
+            font-family: Arial, sans-serif;
+            border-collapse: collapse;
+            width: 100%;
+        }}
+        th, td {{
+            border: 1px solid #dddddd;
+            text-align: left;
+            padding: 8px;
+        }}
+        th {{
+            background-color: #f2f2f2;
+        }}
+        tr:nth-child(even) {{
+            background-color: #f9f9f9;
+        }}
+    </style>
+</head>
+<body>
+Bonjour à tous,<br>
+<br>
+L'exécution du job <strong>{etl_name}</strong> est terminée.<br>
+<br>
+Ci-dessous le statut de mise à jour des tables:
+<br>
+<table>
+    <tr>
+        <th>Check Date</th>
+        <th>Table ID</th>
+        <th>Table Name</th>
+        <th>Last Date</th>
+        <th>Load Date</th>
+        <th>Status</th>
+        <th>Missing Dates</th>
+    </tr>
+    {html_table}
+</table>
+
+<br>
+Bonne réception.<br>
+Big Data & Customer Analytics
+<hr>
+<i>Attention : Ce mail a été généré automatiquement.</i>
+</body>
+</html>
+"""
+##################################################################################################
+
+def generate_mail(etl_name, html_table, html_template=MAIL_CONTENT):
+    """
+    Generate the HTML content for the email.
+    
+    Args:
+        html_template (str): The HTML template for the email.
+        etl_name (str): The name of the ETL process.
+        
+    Returns:
+        str: The generated HTML content.
+    """
+    return html_template.format(etl_name=etl_name, html_table=open(html_table, "r").read())
+
+

{db_analytics_tools-0.2 → db_analytics_tools-0.2.1}/db_analytics_tools/webapp.py

@@ -12,6 +12,7 @@
 # Package Imports
 #####################################################################################################################################
 import os
+import io
 import json
 import time
 import datetime
@@ -19,6 +20,7 @@ import argparse
 import subprocess
 import tempfile
 import threading
+from textwrap import dedent
 
 import streamlit as st
 import pandas as pd
@@ -29,6 +31,7 @@ import db_analytics_tools as db
 import db_analytics_tools.integration as dbi
 from db_analytics_tools.airflow import AirflowRESTAPI
 from db_analytics_tools.scheduler import CronManager
+from db_analytics_tools.mail import MailSender
 #####################################################################################################################################
 
 
@@ -57,8 +60,10 @@ class DBAnalyticsUI:
         self.config = config
         self.app_name = config.get("app_name", "DB Analytics Tools UI")
         self.app_logo = config.get("app_logo", "")
-        self.allowed_users = config.get("allowed_users", [])
-        
+        self.allowed_users = config.get("auth_config", {}).get("allowed_users", [])
+        self.auth_enabled = config.get("auth_config", {}).get("auth_enabled", False)
+        self.mail_enabled = config.get("email_support", {}).get("email_host", None)
+
         #############################################################################################################################
         # Initialize session state variables if they don't exist
         #############################################################################################################################
@@ -75,6 +80,51 @@ class DBAnalyticsUI:
         for key, value in initial_state.items():
             if key not in st.session_state:
                 st.session_state[key] = value
+                
+        self.setup_mail_sender()
+    #################################################################################################################################
+    
+
+    #################################################################################################################################
+    # Mail Sender Setup
+    #################################################################################################################################
+    def setup_mail_sender(self):
+        """
+        Initializes the MailSender instance based on the configuration.
+        """
+        if self.mail_enabled:
+            email_config = self.config.get("email_support", {})
+            self.mail_sender = MailSender(
+                email_host=email_config.get("email_host"),
+                email_port=email_config.get("email_port"),
+                email_user=email_config.get("email_user"),
+                email_password=email_config.get("email_password"),
+                email_use_tls=email_config.get("email_use_tls", True),
+                email_use_ssl=email_config.get("email_use_ssl", False),
+                email_from=email_config.get("email_from", None)
+            )
+            self.email_destinator = email_config.get("email_destinator", [])
+        else:
+            self.mail_sender = None
+            
+    def send_mail_notification(self, subject, message, to_addresses):
+        """
+        Sends an email notification using the configured MailSender.
+
+        :param subject: The subject of the email.
+        :param message: The body content of the email.
+        :param to_addresses: A list of recipient email addresses.
+        """
+        if not self.mail_enabled or not self.mail_sender or not self.email_destinator:
+            print("Email support is not configured. Cannot send email notification.")
+            return
+        
+        try:
+            with self.mail_sender as sender:
+                sender.send_mail(receiver_address=to_addresses, subject=subject, body_html=message)
+            print(f"Email notification sent to {to_addresses}")
+        except Exception as e:
+            print(f"Failed to send email notification: {e}")
     #################################################################################################################################
 
 
@@ -90,8 +140,13 @@ class DBAnalyticsUI:
         #############################################################################################################################
         # 1. Authentication
         #############################################################################################################################
-        if not self.check_auth() or not st.session_state.auth_status:
-            return
+        if (not self.auth_enabled) or (not self.check_auth()) or (not st.session_state.auth_status):
+            if (not self.auth_enabled):
+                st.session_state.user = "Guest"
+                st.session_state.auth_status = True
+                st.warning("Authentication is disabled. Visitor access granted with limited functionality.", width='stretch')
+            else:
+                return
 
         #############################################################################################################################
         # 2. Sidebar Management
@@ -309,7 +364,7 @@ class DBAnalyticsUI:
                         if is_disabled:
                             if st.button("✅ Enable Job", width='stretch'):
                                 cron_manager.enable(comment=selected_job_id)
-                                st.success(f"Job {selected_job} enabled.")
+                                st.success(f"Job {selected_job} auth_enabled.")
                         else:
                             if st.button("🗑️ Disable Job", type="primary", width='stretch'):
                                 cron_manager.disable(comment=selected_job_id)
@@ -617,30 +672,67 @@ class DBAnalyticsUI:
 
         duration = datetime.datetime.now() - duration
         result = f"✅ Pipeline: {selected_pipeline} | Total duration: {duration}"
+        
+        if mail_notification and self.mail_enabled:
+            try:
+                clean_result = str(result).replace('|', '<br>') if result else "No summary details provided."
+                subject = f"DB Analytics Tools - Pipeline Execution Completed: {selected_pipeline}"
+                message = dedent(f"""\
+                    <html>
+                    <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #333333;">
+                        <p>Hi,</p>
+                        <div style="margin: 15px 0;">
+                            {clean_result}
+                        </div>
+                        <p>Regards,<br>
+                        <strong>DB Analytics Tools</strong></p>
+                    </body>
+                    </html>
+                """)
+                self.send_mail_notification(
+                    subject=subject,
+                    message=message,
+                    to_addresses=self.email_destinator,
+                )
+            except Exception as e:
+                print(f"Failed to send email notification: {e}")
         return result
     
-    def extract_sub_module(self, df, table=None):
+    def render_export_button(self, df: pd.DataFrame, table: str = None):
         """
-        Extracts the sub-module name from a full module path in the 'module' column of the provided DataFrame.
-        The sub-module is defined as the last segment of the module path after splitting by dots.
+        Prepares and displays a Streamlit download button to export the DataFrame as a CSV file.
+        Optimized to handle memory efficiently and use proper Streamlit layout properties.
 
-        :param df: A pandas DataFrame containing a 'module' column with full module paths.
-        :param table: The name of the table for which to generate the filename. If None, a default name will be used.
+        :param df: A pandas DataFrame containing the data to be exported.
+        :param table: Optional table name used to generate a descriptive export filename.
         """
-        # Prepare CSV data and filename for download
-        csv_data = df.to_csv(index=False, sep=';', encoding='utf-8')
-        file_prefix = table.replace('.', '__') if table else "table"
-        file_suffix = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
-        filename_csv = f"{file_prefix}_{file_suffix}_export.csv"
+        if df is None or df.empty:
+            st.warning("No data available to export.")
+            return
+
+        # Prepare a clean file prefix and suffix for the export file
+        file_prefix = table.replace('.', '__') if table else "query_export"
+        file_suffix = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        filename_csv = f"{file_prefix}_{file_suffix}.csv"
+        
+        # Optimize CSV generation in memory to prevent app slowdowns on large DataFrames
+        try:
+            # We use an in-memory string buffer to avoid duplicating heavy string allocations
+            buffer = io.StringIO()
+            df.to_csv(buffer, index=False, sep=';', encoding='utf-8')
+            csv_data = buffer.getvalue()
+        except Exception as e:
+            st.error(f"Failed to generate CSV export: {e}")
+            return
         
-        # Download button
+        # Streamlit download button
         st.download_button(
             label='Export Table 💾',
             data=csv_data,
             file_name=filename_csv,
             mime="text/csv",
-            help="Click to download the previewed data as a CSV file",
-            width='stretch'
+            help="Click to download the displayed data as a semi-colon separated CSV file",
+            width='content'
         )
     #################################################################################################################################
 
@@ -791,11 +883,11 @@ class DBAnalyticsUI:
             
         with col_notify:
             # Clean layout for notification toggles without redundant checkbox logic
-            mail_notification = st.checkbox("Activate Email Notification", value=True)
+            mail_notification = st.checkbox("Activate Email Notification", value=False, disabled=self.mail_enabled is None or self.email_destinator == [])
             # Run in background option only for custom mode
             run_background = st.checkbox(
                 "Run in Background", 
-                value=False, 
+                value=False,
                 # disabled=(type_etl == "Custom")
             )
             
@@ -853,7 +945,7 @@ class DBAnalyticsUI:
         # 3. PROCESSING & EXECUTION HANDLING
         # =====================================================================
         if submit_execution:
-            if not selected_pipeline or not selected_pipeline.strip():
+            if (not selected_pipeline) or (not selected_pipeline.strip()):
                 st.error("Validation Error: Please specify the name of the target function or procedure.")
                 return
 
@@ -1139,81 +1231,103 @@ class DBAnalyticsUI:
         #############################################################################################################################
         with col2:
             st.subheader("Export data from table")
-            tables = client.get_tables(include_all=True, include_size=False)
+            
+            try:
+                tables = client.get_tables(include_all=True, include_size=False)
+                available_tables = tables['full_tablename'].unique()
+            except Exception as e:
+                st.error(f"Failed to load database tables: {e}")
+                return
             
             selected_table = st.selectbox(
                 "Select the table to export", 
-                tables['full_tablename'].unique(),
+                available_tables,
                 key="export_target_table_selectbox"
             )
             
-            # Save keys
+            # Session State Cache identifiers
             cached_df_key = "export_cached_preview_df"
             cached_table_key = "export_cached_preview_table_name"
             
+            # Flush old cache if user switches target tables to prevent exporting incorrect data
             if cached_table_key in st.session_state:
                 if st.session_state[cached_table_key] != selected_table:
-                    # Clean cache if user selects another table to avoid confusion
                     st.session_state.pop(cached_df_key, None)
                     st.session_state.pop(cached_table_key, None)
             
-            # Preview button
-            if st.button("Preview table", width='stretch'):
+            # Execute table extraction
+            if st.button("Preview table", width='content'):
                 try:
-                    # Sample the table, then store the data and the name of the active table
-                    df_preview = client.sample_table(selected_table, 10)
+                    sql_query = f"SELECT * FROM {selected_table}"
+                    df_preview = client.read_sql(sql_query)
+                    
+                    # Store the complete pulled dataframe and current active table name inside session state
                     st.session_state[cached_df_key] = df_preview
                     st.session_state[cached_table_key] = selected_table
                 except Exception as e:
                     st.error(f"Failed to fetch preview: {e}")
-            
-            # If the cache contains a preview for the active table, display it and the download button
+
+            # Safe rendering from cache (Crucial: prevents crash during download triggers!)
             if cached_df_key in st.session_state:
                 df_preview_cached = st.session_state[cached_df_key]
                 
-                st.dataframe(df_preview_cached, width='stretch', hide_index=True)
-                
-                self.extract_sub_module(df_preview_cached, selected_table)
+                st.markdown("### Table Preview (First 10 rows)")
+                st.dataframe(df_preview_cached.head(10), width='content', hide_index=True)
+                                
+                # BUG FIX: Pass the persistent cached DataFrame, not local variables which reset on rerun!
+                self.render_export_button(df_preview_cached, selected_table)
         #############################################################################################################################
 
     def db_page_query_console(self):
         """
-        Exploration of tables, sizing, and basic database management.
+        Exploration of tables, query execution, and secure in-memory caching.
         """
         st.header("Query Console 🎮")
-        client = st.session_state.current_client
+        client = st.session_state.get("current_client")
         
+        if not client:
+            st.error("No active database client found. Please connect to a database first.")
+            return
+
         st.markdown("---")
         query = st.text_area(
             label="Drop your query (without ; at the end)",
-            value="""select *
-from public.example_table
-limit 100""",
+            value="""SELECT *
+FROM public.example_table
+LIMIT 100""",
+            height=150
         )
         
-        # Initialize session state keys if they don't exist
-        if "query_result_df" not in st.session_state:
-            st.session_state.query_result_df = None
+        # Initialize session state cache keys safely
+        if "query_result_df_cached" not in st.session_state:
+            st.session_state.query_result_df_cached = None
         if "last_executed_query" not in st.session_state:
             st.session_state.last_executed_query = None
 
-        # Trigger execution and store the dataframe in session state
-        if st.button("Run query", type="primary", width='stretch'):
+        # Execute query block
+        if st.button("Run query", type="primary", width='content'):
             try:
-                # Wrap the query to safely enforce a standard preview limit
-                preview_query = f"({query}) AS foo"
-                st.session_state.query_result_df = client.sample_table(preview_query, 100)
+                # Execute query and pull results
+                raw_df = client.read_sql(query)
+                
+                # Cache the full DataFrame for download, but only preview a subset if needed
+                st.session_state.query_result_df_cached = raw_df
                 st.session_state.last_executed_query = query
+                
             except Exception as e:
-                st.session_state.query_result_df = None
+                st.session_state.query_result_df_cached = None
                 st.session_state.last_executed_query = None
-                st.error(f"Query execution failed: {e}", width='stretch')
-
-        # Persist the rendering outside of the click event block
-        if st.session_state.query_result_df is not None:
-            st.dataframe(st.session_state.query_result_df, width='stretch', hide_index=True)
-            # Display extraction and download layout seamlessly
-            self.extract_sub_module(st.session_state.query_result_df)
+                st.error(f"Query execution failed: {e}")
+
+        # Persistent rendering block (Runs on every rerun, surviving the button click event state)
+        cached_df = st.session_state.query_result_df_cached
+        if cached_df is not None:
+            # Show a lightweight preview to maintain blazing-fast browser performance
+            st.subheader("Data Preview (Showing first 100 rows)")
+            st.dataframe(cached_df.head(100), width='content', hide_index=True)
+            
+            # Pass the cached dataframe so that the export button works flawlessly on subsequent page clicks
+            self.render_export_button(cached_df, table="custom_query")
     #################################################################################################################################
 
 
@@ -1368,7 +1482,7 @@ import json
 from db_analytics_tools.webapp import DBAnalyticsUI
 
 # Load the configuration
-config_data = {json.dumps(config_data)}
+config_data = {repr(config_data)}
 
 # Start App
 app = DBAnalyticsUI(config_data)

{db_analytics_tools-0.2 → db_analytics_tools-0.2.1}/db_analytics_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: db_analytics_tools
-Version: 0.2
+Version: 0.2.1
 Summary: Databases Tools for Data Analytics
 Home-page: https://joekakone.github.io/db-analytics-tools
 Download-URL: https://github.com/joekakone/db-analytics-tools
@@ -22,6 +22,7 @@ Requires-Dist: streamlit>=1.32.2
 Requires-Dist: matplotlib>=3.4.3
 Requires-Dist: statsmodels>=0.13.5
 Requires-Dist: python-crontab>=3.1.0
+Requires-Dist: apache-airflow>=3.1.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{db_analytics_tools-0.2 → db_analytics_tools-0.2.1}/db_analytics_tools.egg-info/requires.txt

@@ -6,3 +6,4 @@ streamlit>=1.32.2
 matplotlib>=3.4.3
 statsmodels>=0.13.5
 python-crontab>=3.1.0
+apache-airflow>=3.1.0

{db_analytics_tools-0.2 → db_analytics_tools-0.2.1}/setup.py

@@ -7,7 +7,7 @@ with open("README.md", "r") as f:
 
 setup(
     name="db_analytics_tools",
-    version="0.2",
+    version="0.2.1",
     url="https://joekakone.github.io/db-analytics-tools",
     download_url="https://github.com/joekakone/db-analytics-tools",
     project_urls={
@@ -31,6 +31,7 @@ setup(
         "matplotlib>=3.4.3",
         "statsmodels>=0.13.5",
         "python-crontab>=3.1.0",
+        "apache-airflow>=3.1.0",
     ],
     python_requires=">=3.9",
     packages=find_packages(),

db_analytics_tools-0.2/db_analytics_tools/mail.py

@@ -1,76 +0,0 @@
-""""
-Module for generating HTML email content for ETL job status updates.
-"""
-
-
-
-##################################################################################################
-## CONSTANTS
-##################################################################################################
-MAIL_CONTENT = """
-<!DOCTYPE html>
-<html>
-<head>
-    <style>
-        table {{
-            font-family: Arial, sans-serif;
-            border-collapse: collapse;
-            width: 100%;
-        }}
-        th, td {{
-            border: 1px solid #dddddd;
-            text-align: left;
-            padding: 8px;
-        }}
-        th {{
-            background-color: #f2f2f2;
-        }}
-        tr:nth-child(even) {{
-            background-color: #f9f9f9;
-        }}
-    </style>
-</head>
-<body>
-Bonjour à tous,<br>
-<br>
-L'exécution du job <strong>{etl_name}</strong> est terminée.<br>
-<br>
-Ci-dessous le statut de mise à jour des tables:
-<br>
-<table>
-    <tr>
-        <th>Check Date</th>
-        <th>Table ID</th>
-        <th>Table Name</th>
-        <th>Last Date</th>
-        <th>Load Date</th>
-        <th>Status</th>
-        <th>Missing Dates</th>
-    </tr>
-    {html_table}
-</table>
-
-<br>
-Bonne réception.<br>
-Big Data & Customer Analytics
-<hr>
-<i>Attention : Ce mail a été généré automatiquement.</i>
-</body>
-</html>
-"""
-##################################################################################################
-
-def generate_mail(etl_name, html_table, html_template=MAIL_CONTENT):
-    """
-    Generate the HTML content for the email.
-    
-    Args:
-        html_template (str): The HTML template for the email.
-        etl_name (str): The name of the ETL process.
-        
-    Returns:
-        str: The generated HTML content.
-    """
-    return html_template.format(etl_name=etl_name, html_table=open(html_table, "r").read())
-
-