with open(result_file, "w") as f:

              f.write(json.dumps(analyze, indent=2))

          po_langs = detect_languages(package_folder, results_folder)

          for lang in po_langs.keys():

          metadata = dict()

          try:

              metadata = polib.pofile(file).metadata

          except OSError:

              # maybe a polib bug? to investigate before using it in TM

              metadata["Language"] = "error-os"

          if "Language" not in metadata.keys():

              metadata["Language"] = "zzz_null"

          results[metadata.get("Language")] = language

  def describe(lang_folder):

      log_file = os.path.join(results_folder, "build_language_list.log")

      file_object = open(log_file, "w")

      for package in packages:

          discovery_file = os.path.join(package_folder, package, "discover.json")

          with open(discovery_file, "r") as read_file:

                  except UnicodeDecodeError:

                      # encoding error, to investigate before using it in TM

                      error = "error-unicode"

                  except OSError:

                      # maybe a polib bug? to investigate before using it in TM

                      error = "error-os"

                  lang, decision = choose_lang(lang_code, metadata, error)

                      [

                          po,

                          lang_code,

                          str(decision),

                      ]

                  )

                  lang_result = langs.get(lang, dict())

                  po_results = lang_result.get("po", list())

  import json

  import os

  import shutil

  import polib

  import logging

      for package in sorted(packages):

          count += 1

          log.info(" {c}/{t} - {p}".format(c=count, t=len(packages), p=package))

          src_folder = os.path.join(packages_folder, package)

          stats_file = os.path.join(packages_stats_folder, package + ".json")

      log.info("Storing distribution stats")

      if not os.path.exists(distribution_stats_folder):

      stats = dict()

      for file in files:

          try:

              stat = calcstats(file)

          except Exception as e:

      metadata = dict()

      try:

          metadata = polib.pofile(file).metadata

      except OSError:

          # maybe a polib bug? to investigate before using it in TM

          metadata["Language"] = "error-os"

      team = "Unknown..."

      try:

  import tempfile

  import logging

  def main():

      """Handle params"""

      if args.refresh and os.path.isdir(tm_folder):

          shutil.rmtree(tm_folder)

          os.makedirs(tm_folder)

      log.info("Building the translation memory for every languages")

          compendium_file = os.path.join(

              os.path.dirname(os.path.abspath(__file__)), compendium_file

          )

              process_compendium(files, compendium_file, debug_folder)

          tmx_file = os.path.join(tm_folder, lang_code + ".tmx")

              try:

                  process_tmx(lang_code, compendium_file, tmx_file)

              except Exception as e:

                  )

          terminology_file = os.path.join(tm_folder, lang_code + ".terminology.po")

              try:

                  process_terminology(compendium_file, terminology_file)

              except Exception as e:

                      )

                  )

      log.info("All languages are processed")

      log.info("Detecting missing files")

      for lang in sorted(langs):

  def process_compendium(langfiles, dest, debug_folder):

                      subprocess.run(command, check=True, cwd=tmp, capture_output=True)

                  except subprocess.CalledProcessError as e:

                      debug_filename = "tm-msguniq-{lang}-{name}".format(lang=dest.split("/")[-1], name=count.__str__())

                      shutil.copyfile(i, os.path.join(debug_folder, debug_filename))

              count += 1

      else:

          if doubt is not False:

              log.debug("This file raised a msgcat bug: {f}".format(f=doubt))

              ongoing = []

          half = int(len(ongoing) / 2)

  def process_tmx(lang, source, dest):

      """ Generate a translation memory from a po file """

      command = ["po2tmx", "--language=" + lang, "--progress=none", source, "--output=" + dest]

      subprocess.run(command, check=True, capture_output=True)

  def process_terminology(source, dest):

      """ Generate a termonology from a po file """

      command = ["poterminology", "--ignore-case", "--fold-titlecase",

      subprocess.run(command, check=True, capture_output=True)

      """ Check if expected files were generated """

      log = logging.getLogger("buildTm.check_lang")

      tmx_file = os.path.join(tm_folder, lang + ".tmx")

      terminology_file = os.path.join(tm_folder, lang + ".terminology.po")

          log.warning("{l}-compendium is missing".format(l=lang))

          log.warning("{l}-tmx is missing".format(l=lang))

          log.warning("{l}-terminology is missing".format(l=lang))

      """ Compress files uzing gzip """

      log = logging.getLogger("buildTm.compress")

  if __name__ == "__main__":

  # parcourir tous les fichiers rpm d'une version et en extraire tous les fichiers de traduction

  # ~ 3 h (without downloading time)

  # déduire la liste de toutes les langues

  # ~ 25 m

  # générer un fichier d'analyse de la langue (quels fichiers, équipes, pluriels, etc.)

  # ~ 3 m