Move website files back to website directory for GitHub Pages

Author: Robbie

.gitignore

@@ -0,0 +1,38 @@
+# Byte-compiled Python files
+*.pyc
+*.pyo
+__pycache__/
+
+# Virtual environment
+.venv/
+env/
+venv/
+
+# Logs and output files
+
+# Cache and temporary files
+*.cache/
+*.bak/
+*.swp
+*.tmp
+*.~*
+.DS_Store
+thumbs.db
+
+# Documentation and reports
+
+
+# Data and checkpoints
+
+
+# Config and explanation files
+
+
+# Templates and testing
+templates/
+tests/
+posts/
+versions/
+wiki/
+
+# Image files and assets

ExampleExperiment_experiment.log

@@ -0,0 +1,13 @@
+2025-04-28 10:14:41,638 - INFO - Starting experiment: ExampleExperiment
+2025-04-28 10:14:41,638 - INFO - Metadata: {'author': 'OpenSourceContributor'}
+2025-04-28 10:14:41,638 - INFO - Running trial 1 out of 5
+2025-04-28 10:14:41,638 - INFO - Trial 1 result: 43
+2025-04-28 10:14:41,638 - INFO - Running trial 2 out of 5
+2025-04-28 10:14:41,638 - INFO - Trial 2 result: 38
+2025-04-28 10:14:41,638 - INFO - Running trial 3 out of 5
+2025-04-28 10:14:41,638 - INFO - Trial 3 result: 43
+2025-04-28 10:14:41,638 - INFO - Running trial 4 out of 5
+2025-04-28 10:14:41,638 - INFO - Trial 4 result: 73
+2025-04-28 10:14:41,638 - INFO - Running trial 5 out of 5
+2025-04-28 10:14:41,638 - INFO - Trial 5 result: 71
+2025-04-28 10:14:41,638 - INFO - Experiment ExampleExperiment completed in 0:00:00.000474

advanced_pipeline_report.pdf

@@ -0,0 +1,95 @@
+import logging
+import time
+import psutil
+
+
+class AdvancedMonitoring:
+    """
+    Provides advanced monitoring functionality for system performance, including
+    real-time metrics collection, periodic logging, and logging configuration.
+
+    The class contains static methods to monitor system performance with details
+    such as CPU usage, memory usage, and latency. It supports periodic logging
+    of these metrics and allows configuring the logging behavior for customization.
+
+    :ivar attribute1: No attributes are defined in this class as it contains
+                      only static methods.
+    """
+
+    @staticmethod
+    def monitor_performance():
+        """
+        Monitors real-time system performance and returns a performance report.
+
+        :return: dict containing performance metrics such as CPU usage, memory usage, and latency.
+        """
+        logging.info("Starting advanced performance monitoring...")
+
+        # Collecting system metrics using psutil
+        cpu_usage = psutil.cpu_percent(interval=1)  # CPU usage as percentage
+        memory_info = psutil.virtual_memory()  # Memory usage information
+        latency = AdvancedMonitoring.simulated_latency()  # Simulated latency for demonstration
+
+        # Creating a performance report
+        performance_report = {
+            "cpu_usage": f"{cpu_usage}%",
+            "memory_usage": f"{memory_info.used / (1024 ** 2):.2f} MB",  # Convert to MB
+            "latency": f"{latency} ms"
+        }
+
+        # Logging the report
+        logging.info("Performance Monitoring Report Generated.")
+        logging.debug(f"Performance Details: {performance_report}")
+        return performance_report
+
+    @staticmethod
+    def simulated_latency():
+        """
+        Simulates latency measurement for demonstration purposes.
+        Replace this with actual model or process latency in real implementations.
+
+        :return: Simulated latency in milliseconds.
+        """
+        # Simulating latency measurement
+        return round(200 + (time.time() % 10))  # Example: fluctuates slightly for a realistic demo
+
+    @staticmethod
+    def log_periodic_metrics(interval=60):
+        """
+        Logs system performance metrics at regular intervals.
+
+        :param interval: Time interval in seconds for periodic logging.
+        """
+        logging.info("Starting periodic performance logging...")
+        try:
+            while True:
+                metrics = AdvancedMonitoring.monitor_performance()
+                logging.info(f"Periodic Metrics: {metrics}")
+                time.sleep(interval)
+        except KeyboardInterrupt:
+            logging.info("Advanced Monitoring terminated by user.")
+
+    @staticmethod
+    def setup_logging(level=logging.INFO, log_file=None):
+        """
+        Configures the logging setup for monitoring.
+
+        :param level: Logging level (default: logging.INFO).
+        :param log_file: Optional file path to save logs, logs to console by default.
+        """
+        handlers = [logging.StreamHandler()]
+        if log_file:
+            handlers.append(logging.FileHandler(log_file))
+
+        logging.basicConfig(
+            level=level,
+            format="%(asctime)s - %(levelname)s - %(message)s",
+            handlers=handlers,
+        )
+
+
+if __name__ == "__main__":
+    # Example execution of the script
+    AdvancedMonitoring.setup_logging(level=logging.DEBUG)  # Setting up logging
+    logging.info("Starting AI Advanced Monitoring script...")
+    AdvancedMonitoring.log_periodic_metrics(interval=30)  # Start periodic monitoring every 30 seconds

ai_advanced_monitoring.py

@@ -0,0 +1,98 @@
+import logging
+from fpdf import FPDF
+
+
+class AdvancedReporting:
+    """
+    Provides methods to generate PDF reports summarizing pipeline metrics and insights,
+    and to configure logging for the report generation process.
+
+    This class is designed to handle the creation of professional-quality PDF reports
+    based on given pipeline data. Additionally, it offers a utility to setup logging
+    for monitoring and debugging purposes.
+
+    :ivar default_font: Default font used for the PDF reports.
+    :type default_font: str
+    :ivar default_font_size: Default size of the font used in PDF reports.
+    :type default_font_size: int
+    :ivar log_level: Default logging level for report generation process.
+    :type log_level: int
+    """
+
+    @staticmethod
+    def generate_pdf_report(report_data, output_path):
+        """
+        Generates a PDF report summarizing pipeline metrics and insights.
+
+        :param report_data: Dictionary containing metrics, charts, or summaries.
+        :param output_path: String, the path where the PDF report will be saved.
+        """
+        logging.info("Starting PDF report generation...")
+        try:
+            # Initialize the PDF object
+            pdf = FPDF()
+            pdf.add_page()
+            pdf.set_font("Arial", size=12)
+
+            # Add title
+            pdf.cell(200, 10, txt="Pipeline Report", ln=True, align="C")
+            pdf.ln(10)  # Add a line break
+
+            # Fill the report data into PDF
+            for key, value in report_data.items():
+                if isinstance(value, dict):
+                    # Handle nested dictionaries by flattening them
+                    pdf.cell(200, 10, txt=f"{key}:", ln=True, align="L")
+                    for sub_key, sub_value in value.items():
+                        pdf.cell(200, 10, txt=f"    {sub_key}: {sub_value}", ln=True, align="L")
+                else:
+                    pdf.cell(200, 10, txt=f"{key}: {value}", ln=True, align="L")
+
+            # Save the PDF to the specified output path
+            pdf.output(output_path)
+            logging.info(f"PDF report successfully saved at: {output_path}")
+        except Exception as e:
+            logging.error(f"Failed to generate PDF report: {e}")
+            raise
+
+    @staticmethod
+    def setup_logging(level=logging.INFO, log_file=None):
+        """
+        Configures logging for the report generation process.
+
+        :param level: Logging level (default: logging.INFO).
+        :param log_file: Optional, file path to store logs. Logs to console if not specified.
+        """
+        handlers = [logging.StreamHandler()]
+        if log_file:
+            handlers.append(logging.FileHandler(log_file))
+
+        logging.basicConfig(
+            level=level,
+            format="%(asctime)s - %(levelname)s - %(message)s",
+            handlers=handlers,
+        )
+
+
+if __name__ == "__main__":
+    # Setup logging for the script
+    AdvancedReporting.setup_logging(level=logging.DEBUG)
+
+    logging.info("Advanced Reporting Script Started...")
+
+    # Example Usage: Sample report data
+    example_report_data = {
+        "Model": "Random Forest",
+        "Accuracy": "87%",
+        "Precision": "85%",
+        "Recall": "81%",
+        "Training Summary": {
+            "Training Time": "15 minutes",
+            "Training Data": "Dataset-X",
+        },
+        "Final Comments": "The performance is satisfactory, with opportunities for improvement in recall."
+    }
+
+    # Generating the report
+    output_report_path = "advanced_pipeline_report.pdf"
+    AdvancedReporting.generate_pdf_report(example_report_data, output_report_path)

ai_advanced_reporting.py

@@ -0,0 +1,117 @@
+import smtplib
+from email.mime.text import MIMEText
+import logging
+import os
+
+
+class AlertingSystem:
+    """
+    A system for sending email alerts using SMTP settings.
+
+    This class facilitates the sending of alert emails. It requires SMTP
+    configuration details including server address, port number, sender's and
+    receiver's email addresses, and the sender’s email password. This system
+    ensures secure communication using TLS encryption before sending emails.
+
+    :ivar smtp_settings: Dictionary containing the following SMTP credentials and settings:
+        - smtp_server: SMTP server address
+        - port: SMTP server port
+        - sender_email: The sender's email address
+        - receiver_email: The recipient's email address
+        - password: The sender's email password
+    :type smtp_settings: dict
+    """
+
+    def __init__(self, smtp_settings):
+        """
+        Initialize the AlertingSystem with specified SMTP settings.
+
+        :param smtp_settings: Dictionary containing SMTP credentials and settings:
+            - smtp_server: SMTP server address
+            - port: SMTP server port
+            - sender_email: The sender's email address
+            - receiver_email: The recipient's email address
+            - password: The sender's email password
+        """
+        self.smtp_settings = smtp_settings
+
+    def send_email_alert(self, subject, body):
+        """
+        Sends an alert email to the specified recipient.
+
+        :param subject: Subject of the email
+        :param body: Content of the email
+        """
+        try:
+            # Create the email message
+            msg = MIMEText(body)
+            msg["Subject"] = subject
+            msg["From"] = self.smtp_settings["sender_email"]
+            msg["To"] = self.smtp_settings["receiver_email"]
+
+            # Connect to the SMTP server and send the email
+            with smtplib.SMTP(self.smtp_settings["smtp_server"], self.smtp_settings["port"]) as server:
+                server.starttls()  # Upgrade the connection to secure
+                server.login(self.smtp_settings["sender_email"], self.smtp_settings["password"])
+                server.sendmail(
+                    self.smtp_settings["sender_email"],
+                    self.smtp_settings["receiver_email"],
+                    msg.as_string()
+                )
+                logging.info("Alert email sent successfully.")
+
+        except Exception as e:
+            logging.error(f"Failed to send email alert: {e}")
+
+
+def setup_logging(level=logging.INFO, log_file=None):
+    """
+    Sets up logging for the application by configuring the log level,
+    log format, and output handlers. The function allows the logs
+    to be displayed in the console and optionally saved to a file.
+
+    :param level: The logging level (e.g., logging.INFO, logging.DEBUG).
+    :type level: int
+    :param log_file: The path to a file where logs should be written. If not
+        provided, logs will only appear in the console.
+    :type log_file: str or None
+    :return: None
+    """
+    handlers = [logging.StreamHandler()]
+    if log_file:
+        handlers.append(logging.FileHandler(log_file))
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=handlers
+    )
+
+
+if __name__ == "__main__":
+    # Configure logging
+    setup_logging(log_file="alerting.log")
+
+    # SMTP configuration: Use environment variables or secure storage for sensitive data
+    smtp_settings = {
+        "smtp_server": os.getenv("SMTP_SERVER", "smtp.mailtrap.io"),
+        "port": int(os.getenv("SMTP_PORT", 587)),
+        "sender_email": os.getenv("SMTP_SENDER_EMAIL", "sender@example.com"),
+        "receiver_email": os.getenv("SMTP_RECEIVER_EMAIL", "receiver@example.com"),
+        "password": os.getenv("SMTP_PASSWORD", "your_password"),
+    }
+
+    # Initialize the alerting system
+    alert = AlertingSystem(smtp_settings)
+
+    # Example: Simulating pipeline execution and error alerting
+    try:
+        logging.info("Starting pipeline execution...")
+        # Simulated function: execute_pipeline()
+        raise RuntimeError("Simulated pipeline failure for testing alert email.")
+    except Exception as e:
+        logging.error(f"Pipeline error detected: {e}")
+        alert.send_email_alert(
+            subject="Pipeline Execution Failure!",
+            body=f"The pipeline encountered an error: {e}"
+        )