memoQProject.py 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360
  1. from suds.client import Client
  2. import datetime
  3. import os
  4. import memoQFile
  5. from base64 import b64decode, b64encode
  6. import json
  7. class Languages(object):
  8. """Encapsulates project languages."""
  9. def __init__(self):
  10. self.target = []
  11. self.source = None
  12. class Project(object):
  13. """Encapsulates basic project information."""
  14. def __init__(self):
  15. self.__guid = None
  16. now = datetime.datetime.now()
  17. self.name = 'Test_{}'.format(str(now).replace(":", "-"))
  18. self.domain = "Python"
  19. self.documents = None
  20. self.languages = Languages()
  21. self.deadline = now + datetime.timedelta(days=2)
  22. def get_project_guid(self):
  23. return self.__guid
  24. def set_project_guid(self, value):
  25. self.__guid = value
  26. def populate_project_info(self, projectInfo):
  27. """Populates name, domain, languages, deadline from project information as received
  28. from memoQ server."""
  29. if projectInfo != None:
  30. self.name = projectInfo['Name']
  31. self.domain = projectInfo['Domain']
  32. self.languages.target = [
  33. x for x in projectInfo['TargetLanguageCodes'].string]
  34. self.languages.source = projectInfo['SourceLanguageCode']
  35. self.deadline = projectInfo['Deadline']
  36. class MemoQProject(object):
  37. """Client for memoQ Server projects API."""
  38. def __init__(self):
  39. with open("config.json") as json_file:
  40. self.config = json.load(json_file)
  41. if self.config["api_base_url"] != "":
  42. api_url = self.config["api_base_url"] + \
  43. "/memoqservices/ServerProject?wsdl"
  44. self.client = Client(api_url)
  45. self.project = Project()
  46. def __repr__(self):
  47. if self.project.get_project_guid() != None:
  48. return "{} - {}\n{} - {}\n{}".format(self.project.name, self.project.get_project_guid(), self.project.languages.source, (", ").join([x for x in self.project.languages.target]), str(self.project.deadline))
  49. else:
  50. return "No project!"
  51. def get_project_by_domain(self, domain):
  52. """Gets first project of given domain name."""
  53. filter = self.client.factory.create(
  54. '{http://kilgray.com/memoqservices/2007}ServerProjectListFilter')
  55. filter.Domain = domain
  56. projects = self.client.service.ListProjects(filter)
  57. if projects:
  58. self.project.set_project_guid(projects[0][0]['ServerProjectGuid'])
  59. self.project.populate_project_info(projects[0][0])
  60. else:
  61. self.project.set_project_guid(None)
  62. def get_project_by_guid(self, guid):
  63. """Gets project information for project of given guid."""
  64. project_info = self.client.service.GetProject(guid)
  65. if project_info != None:
  66. self.project.set_project_guid(guid)
  67. self.project.populate_project_info(project_info)
  68. else:
  69. self.project.set_project_guid(None)
  70. def template_project_options(self, template_guid):
  71. """Needs guid of memoQ project template. project.languages.source must be set.
  72. Returns options needed for creating memoQ project from template."""
  73. if self.project.languages.source != None:
  74. options = self.client.factory.create(
  75. '{http://kilgray.com/memoqservices/2007}TemplateBasedProjectCreateInfo')
  76. options.TemplateGuid = template_guid
  77. options.Name = self.project.name
  78. if self.project.languages.source != "":
  79. options.SourceLanguageCode = self.project.languages.source
  80. else:
  81. print("project.languages.source must be set!")
  82. return None
  83. if len(self.project.languages.target):
  84. options.TargetLanguageCodes.string = self.project.languages.target
  85. options.Domain = self.project.domain
  86. options.CreatorUser = self.config["creator_guid"]
  87. return options
  88. else:
  89. return None
  90. def create_project_from_template(self, template_guid=None, options=None):
  91. """Creates memoQ project using predefined options when
  92. provided with template_guid or using provided options.
  93. Sets new project as active project on success."""
  94. if template_guid != None:
  95. options = self.template_project_options(template_guid)
  96. if options != None:
  97. result = self.client.service.CreateProjectFromTemplate(options)
  98. if result.ResultStatus == "Success":
  99. self.get_project_by_guid(result.ProjectGuid)
  100. else:
  101. self.project.set_project_guid(None)
  102. def project_options(self):
  103. """Returns options needed for creating memoQ project. project.languages.source and project.languages.target must be set."""
  104. if len(self.project.languages.target) and self.project.languages.source != None:
  105. options = self.client.factory.create(
  106. '{http://kilgray.com/memoqservices/2007}ServerProjectDesktopDocsCreateInfo')
  107. options.Name = self.project.name
  108. if self.project.languages.source != "":
  109. options.SourceLanguageCode = self.project.languages.source
  110. else:
  111. print("project.languages.source must be set!")
  112. return None
  113. if len(self.project.languages.target):
  114. options.TargetLanguageCodes.string = self.project.languages.target
  115. else:
  116. print("project.languages.target must be set!")
  117. return None
  118. options.Deadline = self.project.deadline
  119. options.RecordVersionHistory = True
  120. options.CreatorUser = self.config["creator_guid"]
  121. resources = self.client.factory.create(
  122. '{http://schemas.datacontract.org/2004/07/MemoQServices}ServerProjectResourcesInPackages')
  123. options.PackageResourceHandling.value = resources.LinkRemote
  124. return options
  125. else:
  126. return None
  127. def create_project(self, options=None):
  128. """Creates memoQ project using predefined or provided options.
  129. Sets new project as active project on success."""
  130. if options == None:
  131. options = self.project_options()
  132. if options != None:
  133. project_guid = self.client.service.CreateProject2(options)
  134. if project_guid != None:
  135. self.get_project_by_guid(project_guid)
  136. else:
  137. self.project.set_project_guid(None)
  138. def import_document(self, path):
  139. """Uploads and then imports given file to active project for all target languages.
  140. Returns true on success."""
  141. file_client = memoQFile.MemoQFile()
  142. file_guid = file_client.upload_file(path)
  143. if file_guid == None:
  144. return False
  145. langs = self.client.factory.create(
  146. '{http://kilgray.com/memoqservices/2007}targetLangCodes')
  147. langs.string = self.project.languages.target
  148. result = self.client.service.ImportTranslationDocument(
  149. self.project.get_project_guid(), file_guid, langs)
  150. if result != None:
  151. return True
  152. else:
  153. return False
  154. def get_project_documents(self):
  155. """Gets list of documents from active project."""
  156. options = self.client.factory.create(
  157. '{http://kilgray.com/memoqservices/2007}ListServerProjectTranslationDocument2Options')
  158. options.FillInAssignmentInformation = True
  159. if self.project.get_project_guid() != None:
  160. self.documents = self.client.service.ListProjectTranslationDocuments2(
  161. self.project.get_project_guid(), options)
  162. def document_guids(self):
  163. """Returns guids of documents from active project."""
  164. if self.documents == None:
  165. self.get_project_documents()
  166. return [x.DocumentGuid for x in self.documents[0]]
  167. def print_documents(self):
  168. """Prints basic information on documents from active project."""
  169. if self.documents == None:
  170. self.get_project_documents()
  171. for document in self.documents[0]:
  172. print("{} ({}) - {}\n".format(document.DocumentName,
  173. document.TargetLangCode, document.DocumentGuid))
  174. def export_documents(self, path):
  175. """Exports all documents from active project to given path.
  176. Prints path to each file on success and returns true."""
  177. if self.project.get_project_guid() == None:
  178. return "No project!"
  179. export_results = []
  180. for guid in self.document_guids():
  181. export_results.append(
  182. self.client.service.ExportTranslationDocument(self.project.get_project_guid(), guid))
  183. file_client = memoQFile.MemoQFile()
  184. if len(export_results):
  185. for document in export_results:
  186. print(file_client.download_file(path, document.FileGuid))
  187. return True
  188. else:
  189. return False
  190. def export_documents2(self, path):
  191. """Exports all documents from active project to given path using extended method.
  192. Prints path to each file on success and returns true."""
  193. if self.project.get_project_guid() == None:
  194. return "No project!"
  195. options = self.client.factory.create(
  196. '{http://kilgray.com/memoqservices/2007}DocumentExportOptions')
  197. options.CopySourceToEmptyTarget = True
  198. export_results = []
  199. for guid in self.document_guids():
  200. export_results.append(self.client.service.ExportTranslationDocument2(
  201. self.project.get_project_guid(), guid, options))
  202. file_client = memoQFile.MemoQFile()
  203. if len(export_results):
  204. for document in export_results:
  205. print(file_client.download_file(path, document.FileGuid))
  206. return True
  207. else:
  208. return False
  209. def statistics_options(self):
  210. """Returns options for statistics."""
  211. options = self.client.factory.create(
  212. '{http://kilgray.com/memoqservices/2007}StatisticsOptions')
  213. options.Analysis_ProjectTMs = True
  214. options.Analysis_Homogenity = True
  215. options.ShowResultsPerFile = True
  216. options.RepetitionPreferenceOver100 = True
  217. statistics_algorithm = self.client.factory.create(
  218. '{http://schemas.datacontract.org/2004/07/MemoQServices}StatisticsAlgorithm')
  219. options.Algorithm.value = statistics_algorithm.MemoQ
  220. return options
  221. def run_statistics(self, options=None):
  222. """Returns statistics (memoQ CSV) for all documents and language
  223. combinations of active project using predefined or provided options,
  224. returns none on failure."""
  225. if options == None:
  226. options = self.statistics_options()
  227. statistics_format = self.client.factory.create(
  228. '{http://schemas.datacontract.org/2004/07/MemoQServices}StatisticsResultFormat')
  229. languages = self.client.factory.create(
  230. '{http://kilgray.com/memoqservices/2007}targetLangCodes')
  231. languages.string = self.project.languages.target
  232. try:
  233. stats = self.client.service.GetStatisticsOnProject(
  234. self.project.get_project_guid(), languages, options, statistics_format.CSV_MemoQ)
  235. if stats.ResultStatus == "Success":
  236. return stats
  237. else:
  238. return None
  239. except Exception as e:
  240. print(str(e))
  241. def save_statistics(self, path, statistics=None, options=None):
  242. """Saves provided statistics (generates them using provided options
  243. if none) to given path (one file per language combination).
  244. Prints path to statistics file(s)."""
  245. if statistics == None:
  246. statistics = self.run_statistics(options=options)
  247. for stat in statistics.ResultsForTargetLangs.StatisticsResultForLang:
  248. filename = '{}_{}.csv'.format(
  249. stat.TargetLangCode, self.project.name)
  250. output_file = os.path.join(path, filename)
  251. with open(output_file, 'wb') as target:
  252. # Statistics are base64 and utf-16 encoded, so we need to
  253. # decode first
  254. stat_data = b64decode(stat.ResultData).decode("utf-16")
  255. # Changing delimiter to ,
  256. stat_data = stat_data.replace(";", ",")
  257. target.write(stat_data.encode("utf-8"))
  258. print(output_file)
  259. def pretranslate_options(self):
  260. """Returns options for pre-translation."""
  261. options = self.client.factory.create(
  262. '{http://kilgray.com/memoqservices/2007}PretranslateOptions')
  263. lookup_behavior = self.client.factory.create(
  264. '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateLookupBehavior')
  265. options.PretranslateLookupBehavior.value = lookup_behavior.GoodMatch
  266. options.GoodMatchRate = 80
  267. # Options for locking 100% matches
  268. options.LockPretranslated = True
  269. pretranslate_state = self.client.factory.create(
  270. '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateStateToConfirmAndLock')
  271. options.ConfirmLockPretranslated.value = pretranslate_state.ExactMatch
  272. final_state = self.client.factory.create(
  273. '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateExpectedFinalTranslationState')
  274. options.FinalTranslationState = final_state.Confirmed
  275. copy_source_options = self.client.factory.create(
  276. '{http://kilgray.com/memoqservices/2007}PretranslateCopySourceToTargetBehavior')
  277. copy_condition = self.client.factory.create(
  278. '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateCopySourceToTargetConditions')
  279. copy_source_options.Condition.value = copy_condition.SegmentsWithOnlyTagsAndWhitespace
  280. copy_source_options.Lock = True
  281. options.CopySourceToTarget = copy_source_options
  282. return options
  283. def pretranslate_project(self, options=None):
  284. """Pretranslate active project using predefined or provided options. Returns true on success."""
  285. if options == None:
  286. options = self.pretranslate_options()
  287. languages = self.client.factory.create(
  288. '{http://kilgray.com/memoqservices/2007}targetLangCodes')
  289. languages.string = self.project.languages.target
  290. result = self.client.service.PretranslateProject(
  291. self.project.get_project_guid(), languages, options)
  292. if result.ResultStatus == "Success":
  293. return True
  294. return False
  295. def delete(self):
  296. """Deletes active project permanently. WARNING! Not possible to recover!"""
  297. self.client.service.DeleteProject(self.project.get_project_guid())