pyxecm 1.5__py3-none-any.whl → 2.0.0__py3-none-any.whl

pyxecm/customizer/translate.py

@@ -1,78 +1,101 @@
-"""
-Experimental module to automate translations
-
-Class: Translator
-Methods:
-
-__init__ : class initializer
-config: Return the configuration parameters
-translate: Translate a string from one language to another using the Google Translate V2 API
-translateV3: Translate a string from one language to another using the Google Translate V3 API
-
-"""
+"""Experimental module to automate translations."""
 
 __author__ = "Dr. Marc Diefenbruch"
-__copyright__ = "Copyright 2024, OpenText"
+__copyright__ = "Copyright (C) 2024-2025, OpenText"
 __credits__ = ["Kai-Philip Gatzweiler"]
 __maintainer__ = "Dr. Marc Diefenbruch"
 __email__ = "mdiefenb@opentext.com"
 
 import logging
+
 import requests
 
-logger = logging.getLogger("pyxecm.customizer.translate")
+default_logger = logging.getLogger("pyxecm.customizer.translate")
+
+REQUEST_TIMEOUT = 60
 
 
 class Translator:
-    """Class for translation of of strings based on the Google Translate API.
-    The class supports V2 and V3 translation APIs
+    """Class Translator is used for translation of of strings based on the Google Translate API.
+
+    The class supports V2 and V3 translation APIs.
     """
 
+    logger: logging.Logger = default_logger
+
     _config = None
     _headers = None
 
-    def __init__(self, api_key: str, project_key: str = "", domain: str = ""):
-        translateConfig = {}
-
-        translateConfig["apiKey"] = api_key
-        translateConfig[
-            "translateUrlV2"
-        ] = "https://translation.googleapis.com/language/translate/v2"
-        translateConfig[
-            "translateUrlV3"
-        ] = "https://translation.googleapis.com/v3/projects/{}:translateText".format(
-            project_key
+    def __init__(
+        self,
+        api_key: str,
+        project_key: str = "",
+        domain: str = "",
+        logger: logging.Logger = default_logger,
+    ) -> None:
+        """Initialize the Translate objects.
+
+        Args:
+            api_key (str):
+                The Google Translate API key.
+            project_key (str, optional):
+                The Google project. Defaults to "".
+            domain (str, optional):
+                The domain. Defaults to "".
+            logger (logging.Logger, optional):
+                The logging object to log all messages. Defaults to default_logger.
+
+        """
+
+        if logger != default_logger:
+            self.logger = logger.getChild("translator")
+            for logfilter in logger.filters:
+                self.logger.addFilter(logfilter)
+
+        translate_config = {}
+
+        translate_config["apiKey"] = api_key
+        translate_config["translateUrlV2"] = "https://translation.googleapis.com/language/translate/v2"
+        translate_config["translateUrlV3"] = "https://translation.googleapis.com/v3/projects/{}:translateText".format(
+            project_key,
         )
-        translateConfig["project"] = project_key
-        translateConfig["parent"] = "projects/{}/locations/global".format(project_key)
-        translateConfig["model"] = f'nmt{":{}".format(domain) if domain else ""}'
+        translate_config["project"] = project_key
+        translate_config["parent"] = "projects/{}/locations/global".format(project_key)
+        translate_config["model"] = f"nmt{':{}'.format(domain) if domain else ''}"
 
         self._headers = {
             "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json; charset=utf-8",
         }
 
-        self._config = translateConfig
+        self._config = translate_config
 
     def config(self) -> dict:
-        """Return the configuration parameters
+        """Return the configuration parameters.
 
         Returns:
-            dict: configuration parameters
+            dict:
+                The onfiguration parameters.
+
         """
 
         return self._config
 
     def translate(self, source_language: str, target_language: str, text: str) -> str:
-        """Translate a string from one language to another using the Google Translate V2 API
+        """Translate a string from one language to another using the Google Translate V2 API.
 
         Args:
-            source_language (str): source language
-            target_language (str): destination language
-            text (str): string to translate
+            source_language (str):
+                The source language.
+            target_language (str):
+                The target language.
+            text (str):
+                The string to translate.
 
         Returns:
-            str: translated string
+            str:
+                The translated string.
+
         """
 
         params = {
@@ -84,10 +107,14 @@ class Translator:
 
         request_url = self.config()["translateUrlV2"]
 
-        response = requests.post(url=request_url, params=params, timeout=None)
+        response = requests.post(
+            url=request_url,
+            params=params,
+            timeout=REQUEST_TIMEOUT,
+        )
 
         if response.status_code != 200:
-            logger.error("Failed to translate text -> %s", response.content)
+            self.logger.error("Failed to translate text -> %s", response.content)
             return None
 
         translated_text = response.json()["data"]["translations"][0]["translatedText"]
@@ -96,16 +123,21 @@ class Translator:
 
     # end method definition
 
-    def translateV3(self, source_language: str, target_language: str, text: str) -> str:
-        """Translate a string from one language to another using the Google Translate V3 API
+    def translate_v3(self, source_language: str, target_language: str, text: str) -> str:
+        """Translate a string from one language to another using the Google Translate V3 API.
 
         Args:
-            source_language (str): source language
-            target_language (str): destination language
-            text (str): string to translate
+            source_language (str):
+                The source language.
+            target_language (str):
+                The destination language.
+            text (str):
+                The string to translate.
 
         Returns:
-            str: translated string
+            str:
+                The translated string.
+
         """
 
         data = {
@@ -118,11 +150,14 @@ class Translator:
         request_url = self.config()["translateUrlV3"]
 
         response = requests.post(
-            url=request_url, headers=request_header, json=data, timeout=None
+            url=request_url,
+            headers=request_header,
+            json=data,
+            timeout=REQUEST_TIMEOUT,
         )
 
         if response.status_code != 200:
-            logger.error("Failed to translate text -> %s", response.content)
+            self.logger.error("Failed to translate text -> %s", response.content)
             return None
 
         translated_text = response.json()["data"]["translations"][0]["translatedText"]

pyxecm/helper/__init__.py

@@ -1,6 +1,9 @@
-"""pyxecm helper classes, not for direct use"""
+"""pyxecm helper classes, not for direct use."""
 
 from .assoc import Assoc
+from .data import Data
+from .logadapter import PrefixLogAdapter
 from .web import HTTP
 from .xml import XML
-from .data import Data
+
+__all__ = ["HTTP", "XML", "Assoc", "Data", "PrefixLogAdapter"]

pyxecm/helper/assoc.py

@@ -1,28 +1,21 @@
-"""
-Extended ECM Assoc Module to implement functions to read / write from
-so called "Assoc" data structures in Extended ECM. Right now this module
-is used to tweak settings in XML-based transport packages that include
-Assoc structures inside some of the XML elements.
-
-Class: Assoc
-Methods:
+"""Assoc Module to implement functions to read / write from so called "Assoc" data structures in Content Server.
 
-stringToDict: convert an Assoc string to an Python dict representing the assoc values
-dictToString: converting an Assoc dict to an Assoc string
+Right now this module is used to tweak settings in XML-based transport packages that include
+Assoc structures inside some of the XML elements.
 """
 
 __author__ = "Dr. Marc Diefenbruch"
-__copyright__ = "Copyright 2024, OpenText"
+__copyright__ = "Copyright (C) 2024-2025, OpenText"
 __credits__ = ["Kai-Philip Gatzweiler"]
 __maintainer__ = "Dr. Marc Diefenbruch"
 __email__ = "mdiefenb@opentext.com"
 
-import re
 import html
+import re
 
 
 class Assoc:
-    """Class to handle Extended ECM Assoc data structures."""
+    """Class Assoc is used to handle Extended ECM Assoc data structures."""
 
     @classmethod
     def is_unicode_escaped(cls, assoc_string: str) -> bool:
@@ -33,6 +26,7 @@ class Assoc:
 
         Returns:
             bool: True if string is in Unicode, False otherwise
+
         """
 
         pattern = r"\\u[0-9a-fA-F]{4}"
@@ -40,58 +34,100 @@ class Assoc:
 
         return len(matches) > 0
 
+    # end method definition
+
     @classmethod
     def escape_unicode(cls, assoc_string: str) -> str:
-        """Escape / Encode a given string in Unicode
+        """Escape / Encode a given string in Unicode.
 
         Args:
-            assoc_string (str): Source string
+            assoc_string (str):
+                The source string to escape.
 
         Returns:
-            str: Escaped string
+            str:
+                The escaped string.
+
         """
 
         encoded_string = assoc_string.encode("unicode_escape")  # .decode()
 
         return encoded_string
 
+    # end method definition
+
     @classmethod
     def unescape_unicode(cls, assoc_string: str) -> str:
-        """Unescape / Decode a given string
+        """Unescape / Decode a given string.
 
         Args:
-            assoc_string (str): Source string
+            assoc_string (str):
+                The source string to unescape.
 
         Returns:
-            str: Unescaped string
+            str:
+                The unescaped string.
+
         """
         try:
             decoded_string = bytes(assoc_string, "utf-8").decode("unicode_escape")
-            return decoded_string
         except UnicodeDecodeError:
             return assoc_string
 
+        return decoded_string
+
+    # end method definition
+
     @classmethod
     def is_html_escaped(cls, assoc_string: str) -> bool:
+        """Check if an Assoc String is HTML escaped.
+
+        Args:
+            assoc_string (str):
+                The string to test for HTML escaping.
+
+        Returns:
+            bool:
+                True = string is HTML escaped, False if now
+
+        """
+
         decoded_string = html.unescape(assoc_string)
+
         return assoc_string != decoded_string
 
+    # end method definition
+
     @classmethod
     def unescape_html(cls, assoc_string: str) -> str:
+        """HTML unescape a a string.
+
+        Args:
+            assoc_string (str): the string to unescape.
+
+        Returns:
+            str: unescaped string
+
+        """
+
         decoded_string = html.unescape(assoc_string)
         return decoded_string
 
+    # end method definition
+
     @classmethod
     def string_to_dict(cls, assoc_string: str) -> dict:
         """Convert an Assoc string to a Python dict.
-           Each comma-separated element of the Assoc will
-           become a dict element.
+
+        Each comma-separated element of the Assoc will become a dict element.
 
         Args:
-            assoc_string (str): Source Assoc string
+            assoc_string (str):
+                The source Assoc string to convert.
 
         Returns:
             dict: Python dict with the Assoc elements
+
         """
 
         if cls.is_html_escaped(assoc_string):
@@ -132,15 +168,20 @@ class Assoc:
 
         return assoc_dict
 
+    # end method definition
+
     @classmethod
     def dict_to_string(cls, assoc_dict: dict) -> str:
-        """Convert a Python dict to an Assoc string
+        """Convert a Python dict to an Assoc string.
 
         Args:
-            assoc_dict (dict): Source dict
+            assoc_dict (dict):
+                The source dictionary to convert.
 
         Returns:
-            str: Assoc string
+            str:
+                The resulting Assoc string.
+
         """
 
         assoc_string: str = "A<1,?,"
@@ -162,20 +203,29 @@ class Assoc:
         assoc_string += ">"
         return assoc_string
 
+    # end method definition
+
     @classmethod
     def extract_substring(
-        cls, input_string: str, start_sequence: str, stop_sequence: str
+        cls,
+        input_string: str,
+        start_sequence: str,
+        stop_sequence: str,
     ) -> str | None:
-        """A generic method to extract a substring that is delimited
-           by a strart and stop sequence.
+        """Extract a substring that is delimited by a start and stop sequence.
 
         Args:
-            input_string (str): Input string to search the delimited substring in.
-            start_sequence (str): Start esequence of characters.
-            stop_sequence (str): Stopß sequence of characters
+            input_string (str):
+                Input string to search the delimited substring in.
+            start_sequence (str):
+                Start esequence of characters.
+            stop_sequence (str):
+                Stop sequence of characters
 
         Returns:
-            str | None: the deliminated substring or None if not found.
+            str | None:
+                The deliminated substring or None if not found.
+
         """
 
         start_index = input_string.find(start_sequence)
@@ -189,17 +239,25 @@ class Assoc:
         end_index += len(stop_sequence)
         return input_string[start_index:end_index]
 
+    # end method definition
+
     @classmethod
     def extract_assoc_string(cls, input_string: str, is_escaped: bool = False) -> str:
-        """Extract an Assoc from a string. The assoc is deliminated by A< ... >.
+        """Extract an Assoc from a string.
+
+        The assoc is deliminated by A< ... >.
 
         Args:
-            input_string (str): Input string that includes the Assoc as a substring.
-            is_escaped (bool, optional): Whether or not the input string includes the
-                                         assoc escaped or not.
+            input_string (str):
+                Input string that includes the Assoc as a substring.
+            is_escaped (bool, optional):
+                Whether or not the input string includes the
+                assoc escaped or not.
 
         Returns:
-            str: the assoc string
+            str:
+                The assoc string.
+
         """
 
         if is_escaped:
@@ -207,3 +265,5 @@ class Assoc:
         else:
             assoc_string = cls.extract_substring(input_string, "A<", ">")
         return assoc_string
+
+    # end method definition