messenger-logger-callback 0.1.0__tar.gz

messenger_logger_callback-0.1.0/PKG-INFO

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: messenger-logger-callback
+Version: 0.1.0
+Summary: A custom logger and Hugging Face Trainer Callback for sending logs to a remote server with authentication.
+Author-email: Riko0 <grigoriyalexeenko@gmail.com>
+Project-URL: Homepage, https://github.com/Riko0/messenger-logger-callback
+Project-URL: Bug Tracker, https://github.com/Riko0/messenger-logger-callback/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.1
+Requires-Dist: transformers>=4.0.0
+
+Messenger Logger Callback
+A custom Hugging Face Trainer Callback for sending training logs and custom data to a remote server with authentication.
+
+Overview
+messenger-logger-callback is a Python library designed to easily integrate remote logging into your Hugging Face Trainer workflows. It provides a TrainerCallback that automatically captures standard training metrics (loss, learning rate, epoch, etc.) and sends them as JSON payloads to a specified HTTP endpoint. Additionally, it offers a flexible method to send arbitrary custom data from anywhere in your application.
+
+This library is particularly useful for:
+
+Centralized logging of machine learning experiments.
+
+Real-time monitoring of training progress on a remote dashboard.
+
+Integrating with custom notification systems (e.g., Telegram bots, Slack webhooks) by having a server endpoint process the received logs.
+
+Features
+Hugging Face Trainer Integration: Seamlessly plugs into the Hugging Face Trainer class.
+
+Automatic Log Capture: Intercepts on_log, on_train_begin, on_train_end, and on_epoch_end events.
+
+Custom Log Sending: Provides a send_custom_log method for sending any arbitrary JSON data.
+
+Flexible Configuration: Server URL and authentication token can be provided via constructor arguments or environment variables.
+
+Robust Error Handling: Includes try-except blocks for network requests to gracefully handle timeouts, connection errors, and HTTP errors, printing informative messages without crashing your training.
+
+Authentication Support: Supports sending a Bearer token in the Authorization header for secure communication with your logging server.
+
+Installation
+You can install messenger-logger-callback using pip:
+
+pip install messenger-logger-callback
+
+Usage
+1. Basic Integration with Hugging Face Trainer
+from transformers import Trainer, TrainingArguments
+from messenger_logger.callback import MessengerLoggerCallback # Assuming your file is in messenger_logger/callback.py
+import os
+
+# --- Configure your server URL and optional authentication token ---
+# Option A: Pass directly to the constructor
+SERVER_URL = "http://your-logging-server.com/api/logs"
+AUTH_TOKEN = "your_secret_api_token"
+
+# Option B: Set as environment variables (recommended for production)
+# os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://your-logging-server.com/api/logs"
+# os.environ["MESSENGER_LOGGER_AUTH_TOKEN"] = "your_secret_api_token"
+
+# Initialize the callback
+# If using environment variables, you can omit server_url and auth_token arguments:
+# messenger_logger = MessengerLoggerCallback(
+#     project_name="my_awesome_model",
+#     run_id="experiment_v2"
+# )
+messenger_logger = MessengerLoggerCallback(
+    server_url=SERVER_URL,
+    project_name="my_awesome_model",
+    run_id="experiment_v2",
+    auth_token=AUTH_TOKEN
+)
+
+# Define your TrainingArguments
+training_args = TrainingArguments(
+    output_dir="./results",
+    num_train_epochs=3,
+    per_device_train_batch_size=8,
+    logging_dir="./logs",
+    logging_steps=100,
+    report_to=["tensorboard"] # You can still report to other services
+)
+
+# Initialize your Trainer (replace with your actual model and dataset)
+# from transformers import AutoModelForSequenceClassification, AutoTokenizer
+# from datasets import load_dataset
+# model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
+# tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+# dataset = load_dataset("imdb")
+# trainer = Trainer(
+#     model=model,
+#     args=training_args,
+#     train_dataset=dataset["train"],
+#     callbacks=[messenger_logger] # Add your custom callback here
+# )
+
+# For demonstration purposes, let's create a dummy Trainer
+class DummyModel:
+    pass
+class DummyDataset:
+    def __len__(self): return 1000
+    def __getitem__(self, idx): return {"input_ids": [1,2,3], "labels": 0}
+
+trainer = Trainer(
+    model=DummyModel(),
+    args=training_args,
+    train_dataset=DummyDataset(),
+    callbacks=[messenger_logger] # Add your custom callback here
+)
+
+# Start training
+print("Starting dummy training...")
+trainer.train()
+print("Dummy training finished.")
+
+2. Sending Custom Logs
+You can send arbitrary data at any point using the send_custom_log method:
+
+from messenger_logger.callback import MessengerLoggerCallback
+import os
+
+# Ensure the logger is initialized (e.g., from environment variables)
+# os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://localhost:5000/api/logs"
+# os.environ["MESSENGER_LOGGER_AUTH_TOKEN"] = "my_custom_token"
+custom_logger = MessengerLoggerCallback(
+    server_url="http://localhost:5000/api/logs", # Or omit if using env vars
+    project_name="my_inference_project",
+    run_id="prediction_run_1"
+)
+
+# Send custom data, e.g., after model evaluation or deployment
+custom_logger.send_custom_log({
+    "event": "model_evaluation_complete",
+    "model_version": "v1.2.0",
+    "evaluation_metrics": {
+        "accuracy": 0.92,
+        "f1_score": 0.915,
+        "precision": 0.90,
+        "recall": 0.93
+    },
+    "dataset_info": "test_set_2023-01-15"
+})
+
+custom_logger.send_custom_log({
+    "event": "alert",
+    "level": "CRITICAL",
+    "message": "High GPU temperature detected on node gpu-01",
+    "temperature_celsius": 85,
+    "timestamp": "2023-10-27T10:30:00Z"
+})
+
+Configuration
+The MessengerLoggerCallback can be configured using:
+
+Constructor Arguments:
+
+server_url (str, optional): The HTTP endpoint to send logs to.
+
+project_name (str, optional): A string identifier for your project (defaults to "default_project").
+
+run_id (str, optional): A unique identifier for the current training run. If not provided, a timestamp-based ID is generated.
+
+auth_token (str, optional): An authentication token to include in the Authorization: Bearer <token> header.
+
+Environment Variables:
+
+MESSENGER_LOGGER_SERVER_URL: Overrides server_url if set.
+
+MESSENGER_LOGGER_AUTH_TOKEN: Overrides auth_token if set.
+
+Precedence: Constructor arguments take precedence over environment variables. If neither is provided for server_url, a ValueError will be raised.
+
+Error Handling
+The library includes robust error handling for network requests. If the logging server is unavailable, times out, or returns an HTTP error (4xx/5xx), a warning or error message will be printed to the console, but your training script will continue to run without interruption.
+
+Example error messages you might see:
+
+Warning: Request to http://localhost:5000/api/logs timed out for step 10. The server did not respond within the expected time.
+
+Error: Could not connect to server at http://localhost:9999/api/logs for step N/A. The server might be unavailable or the URL is incorrect. Error details: ...
+
+Error: HTTP error occurred while sending logs for step 20. Status: 401, Response: Unauthorized. Check server logs for more details.
+
+Local Testing with a Dummy Server
+For local development and testing, you can use a simple Flask server to receive and print the logs:
+
+Save dummy_server.py:
+
+# dummy_server.py
+from flask import Flask, request, jsonify
+import json
+
+app = Flask(__name__)
+
+@app.route('/api/logs', methods=['POST'])
+def receive_logs():
+    data = request.get_json()
+    print("\n--- Received data ---")
+    print(json.dumps(data, indent=2))
+    # Check for Authorization header
+    auth_header = request.headers.get('Authorization')
+    if auth_header:
+        print(f"Authorization Header: {auth_header}")
+    print("---------------------\n")
+    return jsonify({"status": "success", "message": "Log received"}), 200
+
+if __name__ == '__main__':
+    print("Dummy server running on http://127.0.0.1:5000/api/logs")
+    app.run(port=5000)
+
+Install Flask:
+
+pip install Flask
+
+Run the dummy server:
+
+python dummy_server.py
+
+Run your training script (or the example usage from messenger_logger/callback.py's if __name__ == "__main__": block). You will see the logs printed in your dummy server's console.
+
+Contributing
+Contributions are welcome! Please feel free to open issues or submit pull requests on the GitHub repository.
+
+License
+This project is licensed under the MIT License - see the LICENSE file for details.

messenger_logger_callback-0.1.0/README.md

@@ -0,0 +1,212 @@
+Messenger Logger Callback
+A custom Hugging Face Trainer Callback for sending training logs and custom data to a remote server with authentication.
+
+Overview
+messenger-logger-callback is a Python library designed to easily integrate remote logging into your Hugging Face Trainer workflows. It provides a TrainerCallback that automatically captures standard training metrics (loss, learning rate, epoch, etc.) and sends them as JSON payloads to a specified HTTP endpoint. Additionally, it offers a flexible method to send arbitrary custom data from anywhere in your application.
+
+This library is particularly useful for:
+
+Centralized logging of machine learning experiments.
+
+Real-time monitoring of training progress on a remote dashboard.
+
+Integrating with custom notification systems (e.g., Telegram bots, Slack webhooks) by having a server endpoint process the received logs.
+
+Features
+Hugging Face Trainer Integration: Seamlessly plugs into the Hugging Face Trainer class.
+
+Automatic Log Capture: Intercepts on_log, on_train_begin, on_train_end, and on_epoch_end events.
+
+Custom Log Sending: Provides a send_custom_log method for sending any arbitrary JSON data.
+
+Flexible Configuration: Server URL and authentication token can be provided via constructor arguments or environment variables.
+
+Robust Error Handling: Includes try-except blocks for network requests to gracefully handle timeouts, connection errors, and HTTP errors, printing informative messages without crashing your training.
+
+Authentication Support: Supports sending a Bearer token in the Authorization header for secure communication with your logging server.
+
+Installation
+You can install messenger-logger-callback using pip:
+
+pip install messenger-logger-callback
+
+Usage
+1. Basic Integration with Hugging Face Trainer
+from transformers import Trainer, TrainingArguments
+from messenger_logger.callback import MessengerLoggerCallback # Assuming your file is in messenger_logger/callback.py
+import os
+
+# --- Configure your server URL and optional authentication token ---
+# Option A: Pass directly to the constructor
+SERVER_URL = "http://your-logging-server.com/api/logs"
+AUTH_TOKEN = "your_secret_api_token"
+
+# Option B: Set as environment variables (recommended for production)
+# os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://your-logging-server.com/api/logs"
+# os.environ["MESSENGER_LOGGER_AUTH_TOKEN"] = "your_secret_api_token"
+
+# Initialize the callback
+# If using environment variables, you can omit server_url and auth_token arguments:
+# messenger_logger = MessengerLoggerCallback(
+#     project_name="my_awesome_model",
+#     run_id="experiment_v2"
+# )
+messenger_logger = MessengerLoggerCallback(
+    server_url=SERVER_URL,
+    project_name="my_awesome_model",
+    run_id="experiment_v2",
+    auth_token=AUTH_TOKEN
+)
+
+# Define your TrainingArguments
+training_args = TrainingArguments(
+    output_dir="./results",
+    num_train_epochs=3,
+    per_device_train_batch_size=8,
+    logging_dir="./logs",
+    logging_steps=100,
+    report_to=["tensorboard"] # You can still report to other services
+)
+
+# Initialize your Trainer (replace with your actual model and dataset)
+# from transformers import AutoModelForSequenceClassification, AutoTokenizer
+# from datasets import load_dataset
+# model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
+# tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+# dataset = load_dataset("imdb")
+# trainer = Trainer(
+#     model=model,
+#     args=training_args,
+#     train_dataset=dataset["train"],
+#     callbacks=[messenger_logger] # Add your custom callback here
+# )
+
+# For demonstration purposes, let's create a dummy Trainer
+class DummyModel:
+    pass
+class DummyDataset:
+    def __len__(self): return 1000
+    def __getitem__(self, idx): return {"input_ids": [1,2,3], "labels": 0}
+
+trainer = Trainer(
+    model=DummyModel(),
+    args=training_args,
+    train_dataset=DummyDataset(),
+    callbacks=[messenger_logger] # Add your custom callback here
+)
+
+# Start training
+print("Starting dummy training...")
+trainer.train()
+print("Dummy training finished.")
+
+2. Sending Custom Logs
+You can send arbitrary data at any point using the send_custom_log method:
+
+from messenger_logger.callback import MessengerLoggerCallback
+import os
+
+# Ensure the logger is initialized (e.g., from environment variables)
+# os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://localhost:5000/api/logs"
+# os.environ["MESSENGER_LOGGER_AUTH_TOKEN"] = "my_custom_token"
+custom_logger = MessengerLoggerCallback(
+    server_url="http://localhost:5000/api/logs", # Or omit if using env vars
+    project_name="my_inference_project",
+    run_id="prediction_run_1"
+)
+
+# Send custom data, e.g., after model evaluation or deployment
+custom_logger.send_custom_log({
+    "event": "model_evaluation_complete",
+    "model_version": "v1.2.0",
+    "evaluation_metrics": {
+        "accuracy": 0.92,
+        "f1_score": 0.915,
+        "precision": 0.90,
+        "recall": 0.93
+    },
+    "dataset_info": "test_set_2023-01-15"
+})
+
+custom_logger.send_custom_log({
+    "event": "alert",
+    "level": "CRITICAL",
+    "message": "High GPU temperature detected on node gpu-01",
+    "temperature_celsius": 85,
+    "timestamp": "2023-10-27T10:30:00Z"
+})
+
+Configuration
+The MessengerLoggerCallback can be configured using:
+
+Constructor Arguments:
+
+server_url (str, optional): The HTTP endpoint to send logs to.
+
+project_name (str, optional): A string identifier for your project (defaults to "default_project").
+
+run_id (str, optional): A unique identifier for the current training run. If not provided, a timestamp-based ID is generated.
+
+auth_token (str, optional): An authentication token to include in the Authorization: Bearer <token> header.
+
+Environment Variables:
+
+MESSENGER_LOGGER_SERVER_URL: Overrides server_url if set.
+
+MESSENGER_LOGGER_AUTH_TOKEN: Overrides auth_token if set.
+
+Precedence: Constructor arguments take precedence over environment variables. If neither is provided for server_url, a ValueError will be raised.
+
+Error Handling
+The library includes robust error handling for network requests. If the logging server is unavailable, times out, or returns an HTTP error (4xx/5xx), a warning or error message will be printed to the console, but your training script will continue to run without interruption.
+
+Example error messages you might see:
+
+Warning: Request to http://localhost:5000/api/logs timed out for step 10. The server did not respond within the expected time.
+
+Error: Could not connect to server at http://localhost:9999/api/logs for step N/A. The server might be unavailable or the URL is incorrect. Error details: ...
+
+Error: HTTP error occurred while sending logs for step 20. Status: 401, Response: Unauthorized. Check server logs for more details.
+
+Local Testing with a Dummy Server
+For local development and testing, you can use a simple Flask server to receive and print the logs:
+
+Save dummy_server.py:
+
+# dummy_server.py
+from flask import Flask, request, jsonify
+import json
+
+app = Flask(__name__)
+
+@app.route('/api/logs', methods=['POST'])
+def receive_logs():
+    data = request.get_json()
+    print("\n--- Received data ---")
+    print(json.dumps(data, indent=2))
+    # Check for Authorization header
+    auth_header = request.headers.get('Authorization')
+    if auth_header:
+        print(f"Authorization Header: {auth_header}")
+    print("---------------------\n")
+    return jsonify({"status": "success", "message": "Log received"}), 200
+
+if __name__ == '__main__':
+    print("Dummy server running on http://127.0.0.1:5000/api/logs")
+    app.run(port=5000)
+
+Install Flask:
+
+pip install Flask
+
+Run the dummy server:
+
+python dummy_server.py
+
+Run your training script (or the example usage from messenger_logger/callback.py's if __name__ == "__main__": block). You will see the logs printed in your dummy server's console.
+
+Contributing
+Contributions are welcome! Please feel free to open issues or submit pull requests on the GitHub repository.
+
+License
+This project is licensed under the MIT License - see the LICENSE file for details.

messenger_logger_callback-0.1.0/messenger_logger/callback.py

@@ -0,0 +1,245 @@
+import requests
+import json
+import os
+import datetime
+import dataclasses
+from transformers import TrainerCallback, TrainingArguments, TrainerState, TrainerControl
+from typing import Dict, Any, Optional
+
+class MessengerLoggerCallback(TrainerCallback):
+    """
+    A custom Hugging Face Trainer Callback to send training logs and custom data to a remote server.
+
+    This callback intercepts logging events from the Trainer and sends the
+    relevant metrics (loss, learning rate, epoch, etc.) as a JSON payload
+    to a specified HTTP endpoint. It also provides a method to send custom,
+    arbitrary data.
+
+    The server URL and an optional authentication token can be provided directly
+    or read from environment variables (MESSENGER_LOGGER_SERVER_URL and
+    MESSENGER_LOGGER_AUTH_TOKEN).
+
+    Args:
+        server_url (str, optional): The URL of the server endpoint where logs should be sent.
+                                    If not provided, it will attempt to read from
+                                    the MESSENGER_LOGGER_SERVER_URL environment variable.
+                                    Example: "http://your-server.com/api/logs"
+        project_name (str, optional): An identifier for the training project.
+                                      Defaults to "default_project".
+        run_id (str, optional): A unique identifier for the current training run.
+                                If not provided, a unique ID will be generated
+                                based on the current timestamp.
+        auth_token (str, optional): An authentication token to include in the request headers.
+                                    If not provided, it will attempt to read from
+                                    the MESSENGER_LOGGER_AUTH_TOKEN environment variable.
+    """
+    def __init__(self, server_url: Optional[str] = None, project_name: str = "default_project",
+                 run_id: Optional[str] = None, auth_token: Optional[str] = None):
+
+        # Determine server_url
+        self.server_url = server_url if server_url else os.getenv("MESSENGER_LOGGER_SERVER_URL")
+        if not self.server_url:
+            raise ValueError(
+                "server_url must be provided either as an argument or via the "
+                "MESSENGER_LOGGER_SERVER_URL environment variable."
+            )
+
+        # Determine auth_token
+        self.auth_token = auth_token if auth_token else os.getenv("MESSENGER_LOGGER_AUTH_TOKEN")
+        if self.auth_token:
+            print("Authentication token will be used for server requests.")
+
+        self.project_name = project_name
+        # Simple unique ID based on timestamp if not provided
+        self.run_id = run_id if run_id else f"run_{int(datetime.datetime.now().timestamp())}"
+        print(f"MessengerLoggerCallback initialized for project '{self.project_name}', run '{self.run_id}'")
+        print(f"Logs will be sent to: {self.server_url}")
+
+    def _get_trainer_state_info(self, state: TrainerState) -> Dict[str, Any]:
+        """
+        Extracts all attributes from TrainerState into a dictionary using dataclasses.asdict.
+        This handles serialization of basic types and nested dataclasses automatically.
+        """
+        # TrainerState is a dataclass, so dataclasses.asdict can convert it directly.
+        # This will handle nested dataclasses and basic types correctly.
+        return dataclasses.asdict(state)
+
+    def _send_payload(self, payload: Dict[str, Any], step: Optional[int] = None):
+        """Helper method to send a JSON payload to the server with error handling."""
+        headers = {"Content-Type": "application/json"}
+        if self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+
+        try:
+            response = requests.post(self.server_url, json=payload, headers=headers, timeout=10) # Increased timeout to 10 seconds
+            response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
+            # print(f"Successfully sent logs for step {step if step is not None else 'N/A'} to server. Status: {response.status_code}")
+        except requests.exceptions.Timeout:
+            print(f"Warning: Request to {self.server_url} timed out for step {step if step is not None else 'N/A'}. "
+                  "The server did not respond within the expected time.")
+        except requests.exceptions.ConnectionError as e:
+            print(f"Error: Could not connect to server at {self.server_url} for step {step if step is not None else 'N/A'}. "
+                  f"The server might be unavailable or the URL is incorrect. Error details: {e}")
+        except requests.exceptions.HTTPError as e:
+            print(f"Error: HTTP error occurred while sending logs for step {step if step is not None else 'N/A'}. "
+                  f"Status: {e.response.status_code}, Response: {e.response.text}. Check server logs for more details.")
+        except Exception as e:
+            print(f"An unexpected error occurred while sending logs for step {step if step is not None else 'N/A'}: {e}")
+
+    def on_log(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, logs: Dict[str, Any], **kwargs):
+        """
+        Event called after logging.
+
+        This method is triggered by the Trainer when new logs (metrics) are available.
+        It constructs a payload with the current training state and metrics,
+        and sends it to the configured server URL.
+        """
+        payload = {
+            "project_name": self.project_name,
+            "run_id": self.run_id,
+            "event_type": "trainer_log", # Indicate this is a standard trainer log
+            "trainer_state": self._get_trainer_state_info(state),
+            "logs": logs, # The actual metrics (loss, learning_rate, etc.) for the current step
+            "timestamp": datetime.datetime.now().isoformat()
+        }
+        self._send_payload(payload, state.global_step)
+
+    def on_train_begin(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+        """Event called at the beginning of training."""
+        print(f"Training for project '{self.project_name}', run '{self.run_id}' has begun.")
+        self._send_status_update("training_started", state)
+
+    def on_train_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+        """Event called at the end of training."""
+        print(f"Training for project '{self.project_name}', run '{self.run_id}' has ended.")
+        self._send_status_update("training_finished", state)
+
+    def on_epoch_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs):
+        """Event called at the end of an epoch."""
+        print(f"Epoch {state.epoch} ended for project '{self.project_name}', run '{self.run_id}'.")
+        self._send_status_update("epoch_ended", state)
+
+    def _send_status_update(self, event_type: str, state: TrainerState):
+        """Helper to send general status updates."""
+        payload = {
+            "project_name": self.project_name,
+            "run_id": self.run_id,
+            "event_type": event_type,
+            "trainer_state": self._get_trainer_state_info(state),
+            "timestamp": datetime.datetime.now().isoformat()
+        }
+        self._send_payload(payload, state.global_step)
+
+    def send_custom_log(self, custom_data: Dict[str, Any]):
+        """
+        Sends arbitrary custom data to the remote server.
+
+        This method can be called directly by the user at any point in their
+        training script or other parts of their application to send specific
+        information that is not part of the standard Trainer logs.
+
+        Args:
+            custom_data (Dict[str, Any]): A dictionary containing the custom data
+                                          to be sent.
+        """
+        if not isinstance(custom_data, dict):
+            print("Error: custom_data must be a dictionary.")
+            return
+
+        payload = {
+            "project_name": self.project_name,
+            "run_id": self.run_id,
+            "event_type": "custom_log", # Indicate this is a custom log
+            "custom_data": custom_data,
+            "timestamp": datetime.datetime.now().isoformat()
+        }
+        print(f"Sending custom log for project '{self.project_name}', run '{self.run_id}'.")
+        self._send_payload(payload)
+
+# Example Usage (how you would use this in your training script):
+if __name__ == "__main__":
+    # --- Demonstration of MessengerLoggerCallback ---
+    print("--- Demonstrating MessengerLoggerCallback instantiation ---")
+
+    # --- Scenario 1: Using direct arguments ---
+    print("\n--- Scenario 1: Using direct arguments for server_url and auth_token ---")
+    try:
+        my_logger_direct = MessengerLoggerCallback(
+            server_url="http://localhost:5000/api/logs",
+            project_name="my_nlp_project_direct",
+            run_id="experiment_direct_v1",
+            auth_token="my_secret_direct_token"
+        )
+        print("Simulating log event for direct arguments...")
+        dummy_args = TrainingArguments(output_dir="./tmp_output_direct")
+        dummy_state = TrainerState()
+        dummy_state.global_step = 10
+        dummy_state.epoch = 0.1
+        dummy_state.is_training = True
+        dummy_control = TrainerControl()
+        dummy_logs = {"loss": 0.1234}
+        my_logger_direct.on_log(dummy_args, dummy_state, dummy_control, dummy_logs)
+        my_logger_direct.send_custom_log({"message": "Direct argument test complete"})
+    except ValueError as e:
+        print(f"Configuration Error (Direct Arguments): {e}")
+    except Exception as e:
+        print(f"An error occurred during direct argument demonstration: {e}")
+
+    # --- Scenario 2: Using environment variables ---
+    print("\n--- Scenario 2: Using environment variables for server_url and auth_token ---")
+    # Set environment variables for demonstration
+    os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://localhost:5000/api/logs"
+    os.environ["MESSENGER_LOGGER_AUTH_TOKEN"] = "my_secret_env_token"
+
+    try:
+        my_logger_env = MessengerLoggerCallback(
+            project_name="my_nlp_project_env",
+            run_id="experiment_env_v1"
+        ) # server_url and auth_token will be read from env vars
+        print("Simulating log event for environment variables...")
+        dummy_args_env = TrainingArguments(output_dir="./tmp_output_env")
+        dummy_state_env = TrainerState()
+        dummy_state_env.global_step = 20
+        dummy_state_env.epoch = 0.2
+        dummy_state_env.is_training = True
+        dummy_control_env = TrainerControl()
+        dummy_logs_env = {"loss": 0.5678, "learning_rate": 5e-5}
+        my_logger_env.on_log(dummy_args_env, dummy_state_env, dummy_control_env, dummy_logs_env)
+        my_logger_env.send_custom_log({"message": "Environment variable test complete"})
+    except ValueError as e:
+        print(f"Configuration Error (Environment Variables): {e}")
+    except Exception as e:
+        print(f"An error occurred during environment variable demonstration: {e}")
+    finally:
+        # Clean up environment variables after demonstration
+        del os.environ["MESSENGER_LOGGER_SERVER_URL"]
+        if "MESSENGER_LOGGER_AUTH_TOKEN" in os.environ:
+            del os.environ["MESSENGER_LOGGER_AUTH_TOKEN"]
+
+    # --- Scenario 3: Server not available (demonstrate error handling) ---
+    print("\n--- Scenario 3: Demonstrating server unavailability error handling ---")
+    # Point to a non-existent server or port
+    os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://localhost:9999/api/logs" # Assuming nothing runs on 9999
+    try:
+        my_logger_unavailable = MessengerLoggerCallback(
+            project_name="my_nlp_project_unavailable",
+            run_id="experiment_unavailable_v1"
+        )
+        print("Attempting to send log to unavailable server...")
+        dummy_args_un = TrainingArguments(output_dir="./tmp_output_un")
+        dummy_state_un = TrainerState()
+        dummy_state_un.global_step = 30
+        dummy_state_un.epoch = 0.3
+        dummy_state_un.is_training = True
+        dummy_control_un = TrainerControl()
+        dummy_logs_un = {"loss": 0.999}
+        my_logger_unavailable.on_log(dummy_args_un, dummy_state_un, dummy_control_un, dummy_logs_un)
+    except ValueError as e:
+        print(f"Configuration Error (Unavailable Server): {e}")
+    except Exception as e:
+        print(f"An error occurred during unavailable server demonstration: {e}")
+    finally:
+        if "MESSENGER_LOGGER_SERVER_URL" in os.environ:
+            del os.environ["MESSENGER_LOGGER_SERVER_URL"]
+
+    print("\nDemonstration complete. Check the console output for messages.")

messenger_logger_callback-0.1.0/messenger_logger_callback.egg-info/PKG-INFO

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: messenger-logger-callback
+Version: 0.1.0
+Summary: A custom logger and Hugging Face Trainer Callback for sending logs to a remote server with authentication.
+Author-email: Riko0 <grigoriyalexeenko@gmail.com>
+Project-URL: Homepage, https://github.com/Riko0/messenger-logger-callback
+Project-URL: Bug Tracker, https://github.com/Riko0/messenger-logger-callback/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.1
+Requires-Dist: transformers>=4.0.0
+
+Messenger Logger Callback
+A custom Hugging Face Trainer Callback for sending training logs and custom data to a remote server with authentication.
+
+Overview
+messenger-logger-callback is a Python library designed to easily integrate remote logging into your Hugging Face Trainer workflows. It provides a TrainerCallback that automatically captures standard training metrics (loss, learning rate, epoch, etc.) and sends them as JSON payloads to a specified HTTP endpoint. Additionally, it offers a flexible method to send arbitrary custom data from anywhere in your application.
+
+This library is particularly useful for:
+
+Centralized logging of machine learning experiments.
+
+Real-time monitoring of training progress on a remote dashboard.
+
+Integrating with custom notification systems (e.g., Telegram bots, Slack webhooks) by having a server endpoint process the received logs.
+
+Features
+Hugging Face Trainer Integration: Seamlessly plugs into the Hugging Face Trainer class.
+
+Automatic Log Capture: Intercepts on_log, on_train_begin, on_train_end, and on_epoch_end events.
+
+Custom Log Sending: Provides a send_custom_log method for sending any arbitrary JSON data.
+
+Flexible Configuration: Server URL and authentication token can be provided via constructor arguments or environment variables.
+
+Robust Error Handling: Includes try-except blocks for network requests to gracefully handle timeouts, connection errors, and HTTP errors, printing informative messages without crashing your training.
+
+Authentication Support: Supports sending a Bearer token in the Authorization header for secure communication with your logging server.
+
+Installation
+You can install messenger-logger-callback using pip:
+
+pip install messenger-logger-callback
+
+Usage
+1. Basic Integration with Hugging Face Trainer
+from transformers import Trainer, TrainingArguments
+from messenger_logger.callback import MessengerLoggerCallback # Assuming your file is in messenger_logger/callback.py
+import os
+
+# --- Configure your server URL and optional authentication token ---
+# Option A: Pass directly to the constructor
+SERVER_URL = "http://your-logging-server.com/api/logs"
+AUTH_TOKEN = "your_secret_api_token"
+
+# Option B: Set as environment variables (recommended for production)
+# os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://your-logging-server.com/api/logs"
+# os.environ["MESSENGER_LOGGER_AUTH_TOKEN"] = "your_secret_api_token"
+
+# Initialize the callback
+# If using environment variables, you can omit server_url and auth_token arguments:
+# messenger_logger = MessengerLoggerCallback(
+#     project_name="my_awesome_model",
+#     run_id="experiment_v2"
+# )
+messenger_logger = MessengerLoggerCallback(
+    server_url=SERVER_URL,
+    project_name="my_awesome_model",
+    run_id="experiment_v2",
+    auth_token=AUTH_TOKEN
+)
+
+# Define your TrainingArguments
+training_args = TrainingArguments(
+    output_dir="./results",
+    num_train_epochs=3,
+    per_device_train_batch_size=8,
+    logging_dir="./logs",
+    logging_steps=100,
+    report_to=["tensorboard"] # You can still report to other services
+)
+
+# Initialize your Trainer (replace with your actual model and dataset)
+# from transformers import AutoModelForSequenceClassification, AutoTokenizer
+# from datasets import load_dataset
+# model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
+# tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+# dataset = load_dataset("imdb")
+# trainer = Trainer(
+#     model=model,
+#     args=training_args,
+#     train_dataset=dataset["train"],
+#     callbacks=[messenger_logger] # Add your custom callback here
+# )
+
+# For demonstration purposes, let's create a dummy Trainer
+class DummyModel:
+    pass
+class DummyDataset:
+    def __len__(self): return 1000
+    def __getitem__(self, idx): return {"input_ids": [1,2,3], "labels": 0}
+
+trainer = Trainer(
+    model=DummyModel(),
+    args=training_args,
+    train_dataset=DummyDataset(),
+    callbacks=[messenger_logger] # Add your custom callback here
+)
+
+# Start training
+print("Starting dummy training...")
+trainer.train()
+print("Dummy training finished.")
+
+2. Sending Custom Logs
+You can send arbitrary data at any point using the send_custom_log method:
+
+from messenger_logger.callback import MessengerLoggerCallback
+import os
+
+# Ensure the logger is initialized (e.g., from environment variables)
+# os.environ["MESSENGER_LOGGER_SERVER_URL"] = "http://localhost:5000/api/logs"
+# os.environ["MESSENGER_LOGGER_AUTH_TOKEN"] = "my_custom_token"
+custom_logger = MessengerLoggerCallback(
+    server_url="http://localhost:5000/api/logs", # Or omit if using env vars
+    project_name="my_inference_project",
+    run_id="prediction_run_1"
+)
+
+# Send custom data, e.g., after model evaluation or deployment
+custom_logger.send_custom_log({
+    "event": "model_evaluation_complete",
+    "model_version": "v1.2.0",
+    "evaluation_metrics": {
+        "accuracy": 0.92,
+        "f1_score": 0.915,
+        "precision": 0.90,
+        "recall": 0.93
+    },
+    "dataset_info": "test_set_2023-01-15"
+})
+
+custom_logger.send_custom_log({
+    "event": "alert",
+    "level": "CRITICAL",
+    "message": "High GPU temperature detected on node gpu-01",
+    "temperature_celsius": 85,
+    "timestamp": "2023-10-27T10:30:00Z"
+})
+
+Configuration
+The MessengerLoggerCallback can be configured using:
+
+Constructor Arguments:
+
+server_url (str, optional): The HTTP endpoint to send logs to.
+
+project_name (str, optional): A string identifier for your project (defaults to "default_project").
+
+run_id (str, optional): A unique identifier for the current training run. If not provided, a timestamp-based ID is generated.
+
+auth_token (str, optional): An authentication token to include in the Authorization: Bearer <token> header.
+
+Environment Variables:
+
+MESSENGER_LOGGER_SERVER_URL: Overrides server_url if set.
+
+MESSENGER_LOGGER_AUTH_TOKEN: Overrides auth_token if set.
+
+Precedence: Constructor arguments take precedence over environment variables. If neither is provided for server_url, a ValueError will be raised.
+
+Error Handling
+The library includes robust error handling for network requests. If the logging server is unavailable, times out, or returns an HTTP error (4xx/5xx), a warning or error message will be printed to the console, but your training script will continue to run without interruption.
+
+Example error messages you might see:
+
+Warning: Request to http://localhost:5000/api/logs timed out for step 10. The server did not respond within the expected time.
+
+Error: Could not connect to server at http://localhost:9999/api/logs for step N/A. The server might be unavailable or the URL is incorrect. Error details: ...
+
+Error: HTTP error occurred while sending logs for step 20. Status: 401, Response: Unauthorized. Check server logs for more details.
+
+Local Testing with a Dummy Server
+For local development and testing, you can use a simple Flask server to receive and print the logs:
+
+Save dummy_server.py:
+
+# dummy_server.py
+from flask import Flask, request, jsonify
+import json
+
+app = Flask(__name__)
+
+@app.route('/api/logs', methods=['POST'])
+def receive_logs():
+    data = request.get_json()
+    print("\n--- Received data ---")
+    print(json.dumps(data, indent=2))
+    # Check for Authorization header
+    auth_header = request.headers.get('Authorization')
+    if auth_header:
+        print(f"Authorization Header: {auth_header}")
+    print("---------------------\n")
+    return jsonify({"status": "success", "message": "Log received"}), 200
+
+if __name__ == '__main__':
+    print("Dummy server running on http://127.0.0.1:5000/api/logs")
+    app.run(port=5000)
+
+Install Flask:
+
+pip install Flask
+
+Run the dummy server:
+
+python dummy_server.py
+
+Run your training script (or the example usage from messenger_logger/callback.py's if __name__ == "__main__": block). You will see the logs printed in your dummy server's console.
+
+Contributing
+Contributions are welcome! Please feel free to open issues or submit pull requests on the GitHub repository.
+
+License
+This project is licensed under the MIT License - see the LICENSE file for details.

messenger_logger_callback-0.1.0/messenger_logger_callback.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+messenger_logger/__init__.py
+messenger_logger/callback.py
+messenger_logger_callback.egg-info/PKG-INFO
+messenger_logger_callback.egg-info/SOURCES.txt
+messenger_logger_callback.egg-info/dependency_links.txt
+messenger_logger_callback.egg-info/requires.txt
+messenger_logger_callback.egg-info/top_level.txt

messenger_logger_callback-0.1.0/messenger_logger_callback.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

messenger_logger_callback-0.1.0/messenger_logger_callback.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25.1
+transformers>=4.0.0

messenger_logger_callback-0.1.0/messenger_logger_callback.egg-info/top_level.txt

@@ -0,0 +1 @@
+messenger_logger

messenger_logger_callback-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "messenger-logger-callback"
+version = "0.1.0"
+authors = [
+  { name="Riko0", email="grigoriyalexeenko@gmail.com" },
+]
+description = "A custom logger and Hugging Face Trainer Callback for sending logs to a remote server with authentication."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "requests>=2.25.1",
+    "transformers>=4.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/Riko0/messenger-logger-callback"
+"Bug Tracker" = "https://github.com/Riko0/messenger-logger-callback/issues"

messenger_logger_callback-0.1.0/setup.cfg

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