deeplx 2.2.6

A Rust package for unlimited DeepL translation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::{future::Future, pin::Pin, sync::Arc};

use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use deeplx::DeepLXTranslationResult;
use serde::Serialize;

use crate::server::pkgs::{Error, Json};

pub trait TranslateRepo: Send + Sync {
    fn translate<'a>(
        &'a self,
        text: &'a str,
        source_lang: &'a str,
        target_lang: &'a str,
        dl_session: Option<&'a str>,
    ) -> Pin<Box<dyn Future<Output = Result<DeepLXTranslationResult, Error>> + Send + 'a>>;
}

pub struct TranslateUsecase {
    repo: Arc<dyn TranslateRepo>,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "snake_case")]
pub struct TranslateResult {
    pub code: u16,
    pub id: i64,
    pub data: String,
    pub alternatives: Vec<String>,
    pub source_lang: String,
    pub target_lang: String,
    pub method: String,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "snake_case")]
pub struct TranslateResultUnknown {
    pub code: u16,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "snake_case")]
pub struct Translation {
    pub detected_source_language: String,
    pub text: String,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "snake_case")]
pub struct TranslateResultOfficial {
    pub translations: Vec<Translation>,
}

impl TranslateUsecase {
    pub fn new(repo: Arc<dyn TranslateRepo>) -> Self {
        Self { repo }
    }

    pub async fn translate(
        &self,
        text: &str,
        source_lang: &str,
        target_lang: &str,
        dl_session: Option<&str>,
    ) -> Result<Response, Error> {
        let res = self
            .repo
            .translate(text, source_lang, target_lang, dl_session)
            .await?;

        match res.code {
            200 => Ok(Json(TranslateResult {
                code: res.code as u16,
                id: res.id,
                data: res.data,
                alternatives: res.alternatives,
                source_lang: res.source_lang,
                target_lang: res.target_lang,
                method: res.method,
            })
            .with_status_code(StatusCode::OK)
            .into_response()),
            _ => Ok(Json(TranslateResultUnknown {
                code: res.code as u16,
                message: res.message,
            })
            .with_status_code(
                StatusCode::from_u16(res.code as u16).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
            )
            .into_response()),
        }
    }

    pub async fn translate_official(
        &self,
        text: &str,
        target_lang: &str,
    ) -> Result<Response, Error> {
        let res = self.repo.translate(text, "auto", target_lang, None).await?;

        match res.code {
            200 => Ok(Json(TranslateResultOfficial {
                translations: vec![Translation {
                    detected_source_language: res.source_lang,
                    text: res.data,
                }],
            })
            .with_status_code(StatusCode::OK)
            .into_response()),
            _ => Ok(Json(TranslateResultUnknown {
                code: res.code as u16,
                message: res.message,
            })
            .with_status_code(
                StatusCode::from_u16(res.code as u16).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
            )
            .into_response()),
        }
    }
}