This documentation provides an overview and setup guide for a Go-based server designed to handle translation tasks with streaming support. The application leverages Python scripts for actual translation and package management functionalities, taking advantage of both Go's robust HTTP serving capabilities and Python's extensive libraries.
## Overview
The server offers an API endpoint to handle translation requests. It supports streaming of translation processes and package downloads, improving real-time feedback for end-users. It checks whether the necessary language packages are installed and initiates a download if they are missing, before proceeding with the translation.
## Features
- Streaming Translations: Utilizes server-sent events (SSE) to stream translation and download progress to the client.
- Package Management: Automatically checks for the required language packages and downloads them if not present.
- Language Support Checking: Validates if the requested language pairs are installed locally.
## Getting Started
### Prerequisites
Ensure you have the following installed:
- Go (version 1.15 or higher)
- Python (version 3.6 or higher)
- Python packages required by the translator scripts
### Setup
1. Clone the Repository: Clone or download the source code to your local machine.
2. Install Required Python Packages: Navigate to the `translator` directory and install necessary Python packages using pip:
```bash
pip install -r requirements.txt
3. Running the Server: From the root directory of the project, start the server with the following command:
```bash
go run main.go
The server listens on port 53184 by default, but you can set the `PORT` environment variable to use a different port.
## API Usage
To perform a translation, send a JSON-formatted POST request to `/api` with the following structure:
```json
{
"message": "Hello, world!",
"from": "en",
"to": "de"
}
```
-`message`: The text you wish to translate.
-`from`: The source language code (ISO 639-1 format).
-`to`: The target language code (ISO 639-1 format).
The response will be a stream of translation progress, including package download updates if necessary.
## Code Structure
### Main Components
-`Message` and `StreamResponse` structs: Define the structures for handling translation requests and streaming responses.
-`streamResponse`: Sets up the HTTP headers for SSE and streams translation or download progress.
-`downloadPackages`&`executeTranslator`: Handle the package management and execution of translation scripts.
-`CheckLanguagesInstalled`: Checks if the necessary language packages are installed.
-`handleRequest`: API endpoint handler that processes translation requests.
### Considerations
* Verify that both Python and the necessary packages are installed and accessible by the Go application. It is recommended to use a virtual environment for managing Python dependencies.
* Make sure to adjust the Python script paths in the Go code to match your directory structure.
* Customize the error handling and logging mechanisms according to your operational requirements. Consider using structured logging for better log analysis and monitoring.
### Best Practices
* Separate configuration from code by using a configuration file or environment variables.
* Implement security best practices, such as validating and sanitizing user inputs, protecting against common web vulnerabilities, and using secure connections.
* Use continuous integration and testing to ensure the reliability and stability of the application.
### Conclusion
This server application showcases an effective approach to integrating Go's high-performance web serving capabilities with Python's powerful scripting abilities for dynamic content translation and real-time user feedback. By following best practices and continuously monitoring and improving the application, you can build a robust, secure, and scalable solution for your needs.
### License
This project is licensed under the Attribution-NoDerivatives 4.0 International license - see the [LICENSE](.../.././LICENCE) file for details.
