initial

Dockerfile

@@ -0,0 +1,27 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the current directory contents into the container at /app
+COPY . .
+
+# Make port 7860 available to the world outside this container
+# Hugging Face Spaces expects the application to run on port 7860
+EXPOSE 7860
+
+# Define environment variable
+ENV NAME World
+
+# Run app.py when the container launches
+# Use gunicorn for a more robust production server (optional, but recommended)
+# CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app"]
+# Fallback to Flask's built-in server for simplicity
+CMD ["python", "app.py"]

README.md

@@ -1,11 +1,83 @@
 ---
-title: Print
-emoji: 🦀
-colorFrom: purple
-colorTo: gray
+title: Simple Request Logger
+emoji: 📝
+colorFrom: blue
+colorTo: green
 sdk: docker
-pinned: false
-license: apache-2.0
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Simple Request Logging Server (Hugging Face Compatible)
+
+This repository contains a simple Flask application designed to run in a Docker container. It listens for incoming POST requests on the root path (`/`) and logs the request headers and body (JSON or raw) to the standard output. This is useful for debugging or inspecting webhook payloads.
+
+The application is configured to run on port `7860`, which is commonly used for Hugging Face Spaces deployments.
+
+## Files
+
+*   `app.py`: The main Flask application code.
+*   `requirements.txt`: Lists the Python dependencies (Flask).
+*   `Dockerfile`: Instructions for building the Docker image.
+*   `README.md`: This file.
+
+## Prerequisites
+
+*   Docker installed on your system.
+
+## Build the Docker Image
+
+Navigate to the directory containing the `Dockerfile` and run the following command:
+
+```bash
+docker build -t request-logger .
+```
+
+## Run the Docker Container
+
+To run the container and map the internal port `7860` to a port on your host machine (e.g., `7860`), use:
+
+```bash
+docker run -p 7860:7860 request-logger
+```
+
+The server will start, and you should see output indicating it's listening on `0.0.0.0:7860`.
+
+## Sending Requests
+
+You can send POST requests to the server using tools like `curl` or any HTTP client.
+
+**Example using `curl` (JSON payload):**
+
+```bash
+curl -X POST http://localhost:7860/ \
+     -H "Content-Type: application/json" \
+     -H "X-Custom-Header: MyValue" \
+     -d '{"key": "value", "message": "Hello Server!"}'
+```
+
+**Example using `curl` (Form data):**
+
+```bash
+curl -X POST http://localhost:7860/ \
+     -H "Content-Type: application/x-www-form-urlencoded" \
+     -d "param1=value1&param2=value2"
+```
+
+**Example using `curl` (Plain text):**
+
+```bash
+curl -X POST http://localhost:7860/ \
+     -H "Content-Type: text/plain" \
+     -d "This is a plain text body."
+```
+
+## Viewing Logs
+
+The request details (headers and body) will be printed to the terminal where you ran the `docker run` command.
+
+## Deployment on Hugging Face Spaces
+
+1.  Create a new Space on Hugging Face ([https://huggingface.co/new-space](https://huggingface.co/new-space)).
+2.  Choose "Docker" as the Space SDK. The settings in this `README.md` file (like `sdk: docker` and `app_port: 7860`) will configure the Space automatically.
+3.  Upload or push (`git`) the `app.py`, `requirements.txt`, `Dockerfile`, and this updated `README.md` to your Space repository.
+4.  Hugging Face will automatically build the Docker image and deploy the application using the information from the `Dockerfile` and the YAML header in this README. The application will be accessible at `https://<your-username>-<your-space-name>.hf.space/`. Remember that requests should be sent to the root path (`/`).

app.py

@@ -0,0 +1,43 @@
+from flask import Flask, request, jsonify
+import logging
+import sys
+
+# Configure logging to output to stdout
+logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+app = Flask(__name__)
+
+@app.route('/', methods=['POST'])
+def handle_request():
+    """Handles incoming POST requests, logs details, and returns a response."""
+    logging.info("="*20 + " New Request Received " + "="*20)
+
+    # Log headers
+    logging.info("Headers:")
+    for header, value in request.headers.items():
+        logging.info(f"  {header}: {value}")
+
+    # Log JSON body if present
+    content_type = request.headers.get('Content-Type')
+    if content_type and 'application/json' in content_type:
+        try:
+            json_data = request.get_json()
+            logging.info("JSON Body:")
+            logging.info(json_data)
+        except Exception as e:
+            logging.error(f"Error parsing JSON: {e}")
+            logging.info("Raw Body (JSON parsing failed):")
+            logging.info(request.get_data(as_text=True))
+    else:
+        # Log raw body if not JSON
+        logging.info("Raw Body:")
+        logging.info(request.get_data(as_text=True))
+
+    logging.info("="*20 + " End of Request " + "="*20 + "\n")
+
+    return jsonify({"status": "success", "message": "Request received and logged."}), 200
+
+if __name__ == '__main__':
+    # Hugging Face Spaces typically expect the app on port 7860
+    # Using 0.0.0.0 to be accessible externally within the container
+    app.run(host='0.0.0.0', port=7860)

requirements.txt

@@ -0,0 +1 @@
+Flask==3.0.3