<?xml version="1.0" encoding="UTF-8"?>
<description xmlns="http://openoffice.org/extensions/description/2006" xmlns:dep="http://openoffice.org/extensions/description/2006" xmlns:xlink="http://www.w3.org/1999/xlink">
  <identifier value="vnd.include-once.pagetranslate"/>
  <version value="1.9.200"/>
  <display-name>
    <name lang="en">PageTranslate</name>
  </display-name>
  <dependencies>
    <OpenOffice.org-minimal-version value="3.0" dep:name="OpenOffice.org 3.0"/>
  </dependencies>
  <registration>

#!/usr/bin/python
# encoding: utf-8
# api: uno
##type: callback
# category: language
# title: PageTranslate
# description: Action button to get whole Writer document translated
# version: 1.9.200
# state: beta
# author: mario
# url: https://fossil.include-once.org/pagetranslate/
# depends: python:requests (>= 2.5), python:uno
# pack: *.py, pythonpath/*.py, META-INF/*, pkg-desc, *.x*, icons/*
# config:
#    { name: frames, type: bool, value: 0, description: traverse TextFrames }

            # table/cells
            if para.supportsService("com.sun.star.text.TextTable"):
                for cellname in para.getCellNames():
                    self.log.debug("table/cells:cellname = %r", cellname)
                    text = para.getCellByName(cellname).getText()
                    # not an enumeration, but simple linebreak-formatting in cells
                    orig = text.getString()
                    if self.t.skip(orig):
                        continue
                    text.setString(self.t.linebreakwise(orig))
                    self.add_comment(text, orig)
            # subdocuments?
            elif para.supportsService("com.sun.star.text.TextFrame"):
                self.log.debug(".traverse: TextFrame.Enumeration…")
                self.traverse(para.getText().createEnumeration())
            # ignore existing textfields/comments?
            elif para.supportsService("com.sun.star.text.textfield.Annotation"):
                pass
            elif para.supportsService("com.sun.star.text.XTextField"):
                pass
            # a paragraph can be further enumerated for text portions (same character/style attributes),
            # but that will obviously slow things down further / also complicate coherent translations
            elif slow and para.supportsService("com.sun.star.text.Paragraph"): # doesn't work with com.sun.star.container.XEnumerationAccess?
                self.traverse(para.createEnumeration(), slow=0)  # list of TextPortion`s
            # normal flow text / paragraph
            elif para.supportsService("com.sun.star.text.TextContent") or para.supportsService("com.sun.star.text.TextPortion"):
                orig = para.getString()
                if self.t.skip(orig):  # preempt short/empty segments (incidentally preserves Annotations and TextFields)
                    continue
                text = self.t.translate(orig)
                para.setString(text)
                self.add_comment(para, orig)
            else:
                self.log.warning(".traverse: Unsupported document element.")
                #self.mri(para)

    def drawtranslate(self, pages):
        for page_index in range(0, pages.getCount()):
            page = pages.getByIndex(page_index)
            for shape_index in range(0, page.getCount()):
                shape = page.getByIndex(shape_index)
                if shape.supportsService("com.sun.star.drawing.TextShape"):
                    self.log.info(".drawtranslate: shape = %r", str(shape))
                    text = shape.Text.getString()
                    if self.t.skip(text):
                        continue
                    shape.Text.setString(self.t.translate(text))

    #-- TradutorLibreText (selection rewrite)
    def rewrite_selection(self, xTextRange):
        self.log.info(".rewrite_selection() ---- begin ----")

        # Get selected text and language
        string = xTextRange.getString()

# The pythonpath/ directory can be packaged alongside, to inject new python
# packages into LibreOffices` python bundle. Which really just makes sense
# for the Windows package, because distro-packaged Office setups utilize the
# system python path.


all:

	#pip install translate -t ./ --upgrade --no-compile
	pip3 install deep-translator -t ./ --upgrade --no-compile
	# freeze requests at 2.25 (last Python2.7-compatible)
	pip2 install requests==2.25.1 langdetect six -t ./ --upgrade --no-compile

            return self

    http = FakeRequests()
    log.info("using fake_requests() for now")

# headers
http.headers.update({
    "User-Agent": "Mozilla/5.0 (X11; Linux; LibreOffice/7.4), PageTranslate/2.0",
    "Accept-Language": "*; q=1.0",
    "Accept-Encoding": "utf-8"
})

import functools
import itertools
import operator
import sys
import types

__author__ = "Benjamin Peterson <benjamin@python.org>"
__version__ = "1.16.0"


# Useful for very coarse version differentiation.
PY2 = sys.version_info[0] == 2
PY3 = sys.version_info[0] == 3
PY34 = sys.version_info[0:2] >= (3, 4)

            # 32-bit
            MAXSIZE = int((1 << 31) - 1)
        else:
            # 64-bit
            MAXSIZE = int((1 << 63) - 1)
        del X

if PY34:
    from importlib.util import spec_from_loader
else:
    spec_from_loader = None


def _add_doc(func, doc):
    """Add documentation to a function."""
    func.__doc__ = doc


def _import_module(name):

    def _get_module(self, fullname):
        return self.known_modules[self.name + "." + fullname]

    def find_module(self, fullname, path=None):
        if fullname in self.known_modules:
            return self
        return None

    def find_spec(self, fullname, path, target=None):
        if fullname in self.known_modules:
            return spec_from_loader(fullname, self)
        return None

    def __get_module(self, fullname):
        try:
            return self.known_modules[fullname]
        except KeyError:
            raise ImportError("This loader does not know module " + fullname)

    def get_code(self, fullname):
        """Return None

        Required, if is_package is implemented"""
        self.__get_module(fullname)  # eventually raises ImportError
        return None
    get_source = get_code  # same as get_code

    def create_module(self, spec):
        return self.load_module(spec.name)

    def exec_module(self, module):
        pass

_importer = _SixMetaPathImporter(__name__)


class _MovedItems(_LazyModule):

    """Lazy loading of moved objects"""