for name in "DT: Google", "Pons Dict", "DT: Libre":
        assert isinstance(_ab(name), tb.DeepTranslator)
    assert isinstance(_ab("DTA: Any"), tb.DeepTransApi)

def classes():
    assert len(tb.BackendUtils.subclasses()) >= 10

def dec_silence():
    func = tb.BackendUtils.silence(lambda x: undef)
    func(2)

def dec_from_words():
    ls = []
    func = tb.BackendUtils.from_words(lambda text: ls.append(text))
    func("one two three")
    assert len(ls) == 3

import sys
sys.path.append(".")
import pagetranslate as pt

class StubPt(pt.PageTranslate):
    def __init__(self, *x):
        pass

def country():
    p = StubPt()
    assert p.country("it") == "IT"
    assert p.country("en") == "US"
    assert p.country("ilo") == "PH"

# category: transform
# version: 0.5
# state: beta
# license: MITL
# config:
#    { name: source, value: auto, description: assumed source language }
#    { name: target, value: en, description: default target language }
#    { name: linebreakwise, type: bool, value: 0, description: linebreakwise paragraph translation }
#    { name: quick, type: bool, value: 0, description: quick placeholder linebreaks in requests }
# priority: optional
# depends: python >= 3.8, python:PySimpleGUI >= 4.37, python:requests
# pack: pythonpath/*.py=gui/
# architecture: all
# classifiers: translation
# keywords: translation
# url: https://fossil.include-once.org/pagetranslate/

#sys.excepthook = lambda *exc: log.critical(format_exc())


#-- init
conf = dict(
    mode = "page",      # unused
    quick = 0,          # split/iterate over text sections
    linebreakwise = 0,  # individual API requests for paragraphs (not sure we still need it)
    api_key = "",       # API key
    email = "",         # MyMemory email
    cmd = "translate-cli -o -f auto -t {lang} {text}",  # if cli tool
    backend = "GoogleWeb",
    available = [
        "Google Translate",
        "Google Ajax",

        "hu", "is", "ga", "la", "lv", "lt", "lb", "mk", "mt", "ro", "sr", "sk",
        "sl", "uk", "wl", "cy", "yi", "ms", "ha", "ho", "mi", "mh", "tl", "tp",
        "pi", "po", "sm", "lo", "pa", "en", "se", "en", "fl", "en",
    ],
    office = f"TkInter/{tk.TkVersion}",
)
# load config
sg.user_settings_filename(filename="tk_translate.json")
conf.update(sg.user_settings())


# argument
if len(sys.argv) == 2:
    conf["backend"] = sys.argv[1]


#-- widget structure
layout = [[
    sg.Column([
        # top frame
        [
            sg.Combo(values=conf["available"], default_value=conf["backend"], size=(20,25), key="backend", tooltip="Service to use", background_color="#67a"),
            sg.Sizer(h_pixels = 140),
            sg.Combo(values=["auto"]+conf["languages"], default_value=conf["source"], size=(4,1), key="from", tooltip="Source language", background_color="#67a"),
            sg.Sizer(h_pixels = 30),
            sg.Button("➜ Translate ➜", tooltip="Translate to target language"),
            sg.Sizer(h_pixels = 30),
            sg.Combo(values=conf["languages"], default_value=conf["target"], size=(4,30), key="lang", tooltip="Target language", background_color="#67a"),
            sg.Sizer(h_pixels = 225),
            #sg.Checkbox("␤␍⮒", key="linebreakwise", default=False, tooltip="Use .linebreakwise() translation (in case all text gets contracted)"),
            sg.Button("⛭", key="settings", tooltip="Config"),
            sg.Button("File", key="file", tooltip="Translate an OpenOffice or text file"),
        ],
        # tabs
        [
            sg.Multiline(size=(55,20), key="orig", background_color="#cce"),
            sg.Multiline(size=(55,20), key="outp", background_color="#cce"),

        data.update(conf)
        if re.search(r"\{(|text|lang|from)\}|\s(-w\b|--\w\w+)", data["backend"]):
            data.update({
                "cmd": data["backend"],
                "backend": "CLI",
            })
        t = translationbackends.assign_service(data)
        translate = t.linebreakwise if conf.get("linebreakwise") else t.translate
        self.w["outp"].update(translate(data["orig"]))

    # File translation (odt, fodt)
    def file(self, data):
        fn = sg.tk.filedialog.askopenfilename(
            filetypes=[("Office", "*.odt *.fodt *.odg *.fodg *.odp *.fodp"), ("Text", "*.txt *.md"), ("Any", "*")]
        )
        if not fn:
            return

        target_fn = re.sub(r"(\.\w+)$", rf".{data['lang']}\1", fn)
        if os.path.exists(target_fn):
            if sg.popup_yes_no(f"Overwrite {target_fn}?") != "Yes":
                return

        self.t = translationbackends.assign_service(conf)
        if re.search("\.(txt|md|text)$", fn):
            self.file_text(fn, target_fn)
        if re.search("\.(fodt|fodg|fodp)$", fn):
            self.file_xml(fn, target_fn)
        if re.search("\.(odt|odg|odp)$", fn):
            self.file_zip(fn, target_fn)

                self.t.xml(
                    read.read()
                )
            )

    # modify content.xml within zip
    def file_zip(self, fn, target_fn):
        from zipfile import ZipFile, ZIP_DEFLATED

        with ZipFile(fn, 'r') as read, ZipFile(target_fn, 'w', compression=ZIP_DEFLATED) as write:
            for entry in read.infolist():
                data = read.read(entry.filename)
                if entry.filename == "content.xml":
                    data = self.t.xml(data.decode("utf-8"))
                write.writestr(entry.filename, data)



    # File: Settings - remapped to pluginconf window
    def settings(self, data, files=[__file__, translationbackends.__file__]):
        import pluginconf.gui




        if pluginconf.gui.window(conf, {}, files=files, theme="Default1"):


            for key in "backend", "api_key", "email", "cmd", "source", "target", "quick", "linebreakwise":
                sg.user_settings_set_entry(key, conf[key])  # don't fixate other presets




    # File: Exit
    def exit(self, data):
        self.w.close()

    # set mouse pointer ("watch" for planned hangups)
    def _cursor(self, s="arrow"):