Server rewrite/enhancement

examples/response.cpp

@@ -0,0 +1,116 @@
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <cstring>
+#include <cassert>
+
+struct Color {
+    uint8_t fg[3];
+    uint8_t bg[3];
+};
+
+struct Translation {
+    uint32_t min_x;
+    uint32_t min_y;
+    uint32_t max_x;
+    uint32_t max_y;
+    bool is_bulleted_list;
+    uint32_t angle;
+    float prob;
+    Color text_color;
+    std::unordered_map<std::string, std::string> text;
+    std::vector<uint8_t> background;
+};
+
+struct TranslationResponse {
+    std::vector<Translation> translations;
+};
+
+uint32_t read_u32(const std::vector<uint8_t>& bytes, size_t& offset) {
+    uint32_t value;
+    std::memcpy(&value, &bytes[offset], sizeof(value));
+    value = value;
+    offset += 4;
+    return value;
+}
+
+float read_f32(const std::vector<uint8_t>& bytes, size_t& offset) {
+    float value;
+    std::memcpy(&value, &bytes[offset], sizeof(value));
+    value = *reinterpret_cast<uint32_t*>(&value);
+    offset += 4;
+    return value;
+}
+
+uint8_t read_u8(const std::vector<uint8_t>& bytes, size_t& offset) {
+    uint8_t value = bytes[offset];
+    offset += 1;
+    return value;
+}
+
+bool read_bool(const std::vector<uint8_t>& bytes, size_t& offset) {
+    bool value = bytes[offset] != 0;
+    offset += 1;
+    return value;
+}
+
+std::vector<uint8_t> read_chunk(const std::vector<uint8_t>& bytes, size_t& offset) {
+    uint32_t size = read_u32(bytes, offset);
+    std::vector<uint8_t> value(bytes.begin() + offset, bytes.begin() + offset + size);
+    offset += size;
+    return value;
+}
+
+std::string read_str(const std::vector<uint8_t>& bytes, size_t& offset) {
+    std::vector<uint8_t> chunk = read_chunk(bytes, offset);
+    std::string result(chunk.begin(), chunk.end());
+    return result;
+}
+
+std::unordered_map<std::string, std::string> read_map(const std::vector<uint8_t>& bytes, size_t& offset) {
+    uint32_t count = read_u32(bytes, offset);
+    std::unordered_map<std::string, std::string> map;
+    for (uint32_t i = 0; i < count; ++i) {
+        std::string key = read_str(bytes, offset);
+        std::string value = read_str(bytes, offset);
+        map[key] = value;
+    }
+    return map;
+}
+
+Translation from_bytes(const std::vector<uint8_t>& bytes, size_t& offset) {
+    Translation translation;
+    translation.min_x = read_u32(bytes, offset);
+    translation.min_y = read_u32(bytes, offset);
+    translation.max_x = read_u32(bytes, offset);
+    translation.max_y = read_u32(bytes, offset);
+    translation.is_bulleted_list = read_bool(bytes, offset);
+    translation.angle = read_u32(bytes, offset);
+    translation.prob = read_f32(bytes, offset);
+    for (int i = 0; i < 3; ++i) {
+        translation.text_color.fg[i] = read_u8(bytes, offset);
+        translation.text_color.bg[i] = read_u8(bytes, offset);
+    }
+    translation.text = read_map(bytes, offset);
+    translation.background = read_chunk(bytes, offset);
+    return translation;
+}
+
+TranslationResponse from_bytes_response(const std::vector<uint8_t>& bytes) {
+    size_t offset = 0;
+    uint32_t count = read_u32(bytes, offset);
+    TranslationResponse response;
+
+    for (uint32_t i = 0; i < count; ++i) {
+        response.translations.push_back(from_bytes(bytes, offset));
+    }
+    return response;
+}
+
+int main() {
+    std::vector<uint8_t> bytes = {/* byte data here */};
+    TranslationResponse data = from_bytes_response(bytes);
+    return 0;
+}

examples/response.rs

@@ -0,0 +1,101 @@
+#[derive(Debug)]
+struct Color {
+    fg: [u8; 3],
+    bg: [u8; 3],
+}
+
+#[derive(Debug)]
+struct Translation {
+    min_x: u32,
+    min_y: u32,
+    max_x: u32,
+    max_y: u32,
+    is_bulleted_list: bool,
+    angle: u32,
+    prob: f32,
+    text_color: Color,
+    text: HashMap<String, String>,
+    background: Vec<u8>,
+}
+
+#[derive(Debug)]
+struct TranslationResponse {
+    translations: Vec<Translation>,
+}
+
+impl TranslationResponse {
+    fn from_bytes(bytes: &[u8]) -> Self {
+        let mut offset = 0;
+        let v = (0..read_u32(bytes, &mut offset))
+            .map(|_| Translation::from_bytes(bytes, &mut offset))
+            .collect::<Vec<_>>();
+        Self { translations: v }
+    }
+}
+
+fn read_u32(bytes: &[u8], offset: &mut usize) -> u32 {
+    let value = u32::from_le_bytes(bytes[*offset..*offset + 4].try_into().unwrap());
+    *offset += 4;
+    value
+}
+
+impl Translation {
+    fn from_bytes(bytes: &[u8], offset: &mut usize) -> Self {
+        let read_f32 = |bytes: &[u8], offset: &mut usize| -> f32 {
+            let value = f32::from_le_bytes(bytes[*offset..*offset + 4].try_into().unwrap());
+            *offset += 4;
+            value
+        };
+
+        let read_u8 = |bytes: &[u8], offset: &mut usize| -> u8 {
+            let value = bytes[*offset];
+            *offset += 1;
+            value
+        };
+
+        let read_bool = |bytes: &[u8], offset: &mut usize| -> bool {
+            let value = bytes[*offset] != 0;
+            *offset += 1;
+            value
+        };
+
+        let read_chunk = |bytes: &[u8], offset: &mut usize| -> Vec<u8> {
+            let size = read_u32(bytes, offset);
+            let value = &bytes[*offset..*offset + size as usize];
+            *offset += size as usize;
+            value.to_vec()
+        };
+        let read_str = |bytes: &[u8], offset: &mut usize| -> String {
+            String::from_utf8(read_chunk(bytes, offset)).expect("Invalid UTF-8")
+        };
+        let read_map = |bytes: &[u8], offset: &mut usize| -> HashMap<String, String> {
+            (0..read_u32(bytes, offset))
+                .into_iter()
+                .map(|_| (read_str(bytes, offset), read_str(bytes, offset)))
+                .collect::<HashMap<String, String>>()
+        };
+        Self {
+            min_x: read_u32(bytes, offset),
+            min_y: read_u32(bytes, offset),
+            max_x: read_u32(bytes, offset),
+            max_y: read_u32(bytes, offset),
+            is_bulleted_list: read_bool(bytes, offset),
+            angle: read_u32(bytes, offset),
+            prob: read_f32(bytes, offset),
+            text_color: Color {
+                fg: [
+                    read_u8(bytes, offset),
+                    read_u8(bytes, offset),
+                    read_u8(bytes, offset),
+                ],
+                bg: [
+                    read_u8(bytes, offset),
+                    read_u8(bytes, offset),
+                    read_u8(bytes, offset),
+                ],
+            },
+            text: read_map(bytes, offset),
+            background: read_chunk(bytes, offset),
+        }
+    }
+}

manga_translator/__main__.py

@@ -3,13 +3,8 @@
 import logging
 from argparse import Namespace
 
-from manga_translator.share import MangaShare
 from .manga_translator import (
-    MangaTranslator,
-    MangaTranslatorWeb,
-    MangaTranslatorWS,
-    MangaTranslatorAPI,
-    set_main_logger,
+    set_main_logger, load_dictionary, apply_dictionary,
 )
 from .args import parser
 from .utils import (
@@ -27,30 +22,29 @@ async def dispatch(args: Namespace):
 
     logger.info(f'Running in {args.mode} mode')
 
-    if args.mode in ('demo', 'batch'):
+    if args.mode == 'local':
         if not args.input:
             raise Exception('No input image was supplied. Use -i <image_path>')
-        translator = MangaTranslator(args_dict)
+        from manga_translator.mode.local import MangaTranslatorLocal
+        translator = MangaTranslatorLocal(args_dict)
 
         # Load pre-translation and post-translation dictionaries
-        pre_dict = translator.load_dictionary(args.pre_dict)  
-        post_dict = translator.load_dictionary(args.post_dict)  
+        pre_dict = load_dictionary(args.pre_dict)
+        post_dict = load_dictionary(args.post_dict)
 
-        if args.mode == 'demo':
-            if len(args.input) != 1 or not os.path.isfile(args.input[0]):
-                raise FileNotFoundError(f'Invalid single image file path for demo mode: "{" ".join(args.input)}". Use `-m batch`.')
+        if len(args.input) == 1 and os.path.isfile(args.input[0]):
             dest = os.path.join(BASE_PATH, 'result/final.png')
             args.overwrite = True # Do overwrite result/final.png file
 
             # Apply pre-translation dictionaries
             await translator.translate_path(args.input[0], dest, args_dict)
             for textline in translator.textlines:
-                textline.text = translator.apply_dictionary(textline.text, pre_dict)  
+                textline.text = apply_dictionary(textline.text, pre_dict)
                 logger.info(f'Pre-translation dictionary applied: {textline.text}')
 
             # Apply post-translation dictionaries
             for textline in translator.textlines:
-                textline.translation = translator.apply_dictionary(textline.translation, post_dict)  
+                textline.translation = apply_dictionary(textline.translation, post_dict)
                 logger.info(f'Post-translation dictionary applied: {textline.translation}')
 
         else: # batch
@@ -60,37 +54,27 @@ async def dispatch(args: Namespace):
                     # Apply pre-translation dictionaries
                     await translator.translate_path(path, dest, args_dict)
                     for textline in translator.textlines:
-                        textline.text = translator.apply_dictionary(textline.text, pre_dict) 
+                        textline.text = translator.apply_dictionary(textline.text, pre_dict)
                         logger.info(f'Pre-translation dictionary applied: {textline.text}')
 
                     # Apply post-translation dictionaries
                     for textline in translator.textlines:
-                        textline.translation = translator.apply_dictionary(textline.translation, post_dict)  
+                        textline.translation = translator.apply_dictionary(textline.translation, post_dict)
                         logger.info(f'Post-translation dictionary applied: {textline.translation}')
                 except Exception :
                     pass
 
-    elif args.mode == 'web':
-        from .server.web_main import dispatch
-        await dispatch(args.host, args.port, translation_params=args_dict)
-
-    elif args.mode == 'web_client':
-        translator = MangaTranslatorWeb(args_dict)
-        await translator.listen(args_dict)
-
     elif args.mode == 'ws':
+        from manga_translator.mode.ws import MangaTranslatorWS
         translator = MangaTranslatorWS(args_dict)
         await translator.listen(args_dict)
 
-    elif args.mode == 'api':
-        translator = MangaTranslatorAPI(args_dict)
-        await translator.listen(args_dict)
     elif args.mode == 'shared':
+        from manga_translator.mode.share import MangaShare
         translator = MangaShare(args_dict)
         await translator.listen(args_dict)
 
 
-
 if __name__ == '__main__':
     args = None
     init_logging()