Added project pre-translation, few other fixes

memoQProject.py

@@ -101,8 +101,12 @@ class MemoQProject(object):
                 print("project.languages.source must be set!")
                 return None
 
+            if len(self.project.languages.target):
+                options.TargetLanguageCodes.string = self.project.languages.target
+
             options.Domain = self.project.domain
             options.CreatorUser = self.config["creator_guid"]
+
             return options
         else:
             return None
@@ -308,6 +312,49 @@ class MemoQProject(object):
                 target.write(stat_data.encode("utf-8"))
             print(output_file)
 
+    def pretranslate_options(self):
+        """Returns options for pre-translation."""
+        options = self.client.factory.create(
+            '{http://kilgray.com/memoqservices/2007}PretranslateOptions')
+        lookup_behavior = self.client.factory.create(
+            '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateLookupBehavior')
+        options.PretranslateLookupBehavior.value = lookup_behavior.GoodMatch
+        options.GoodMatchRate = 80
+
+        # Options for locking 100% matches
+        options.LockPretranslated = True
+        pretranslate_state = self.client.factory.create(
+            '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateStateToConfirmAndLock')
+        options.ConfirmLockPretranslated.value = pretranslate_state.ExactMatch
+        final_state = self.client.factory.create(
+            '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateExpectedFinalTranslationState')
+        options.FinalTranslationState = final_state.Confirmed
+
+        copy_source_options = self.client.factory.create(
+            '{http://kilgray.com/memoqservices/2007}PretranslateCopySourceToTargetBehavior')
+        copy_condition = self.client.factory.create(
+            '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateCopySourceToTargetConditions')
+        copy_source_options.Condition.value = copy_condition.SegmentsWithOnlyTagsAndWhitespace
+        copy_source_options.Lock = True
+        options.CopySourceToTarget = copy_source_options
+
+        return options
+
+    def pretranslate_project(self, options=None):
+        """Pretranslate active project using predefined or provided options. Returns true on success."""
+        if options == None:
+            options = self.pretranslate_options()
+
+        languages = self.client.factory.create(
+            '{http://kilgray.com/memoqservices/2007}targetLangCodes')
+        languages.string = self.project.languages.target
+
+        result = self.client.service.PretranslateProject(
+            self.project.get_project_guid(), languages, options)
+        if result.ResultStatus == "Success":
+            return True
+        return False
+
     def delete(self):
         """Deletes active project permanently. WARNING! Not possible to recover!"""
         self.client.service.DeleteProject(self.project.get_project_guid())

memoQProjectTest.py

@@ -81,6 +81,7 @@ class MemoQProjectTest(unittest.TestCase):
         test.delete()
 
         # Testing override
+        test.project.languages.target = self.config["target_languages"]
         options = test.template_project_options(
             self.config["project_template_guid"])
         options.Name += "_override"
@@ -90,6 +91,8 @@ class MemoQProjectTest(unittest.TestCase):
         self.assertNotEqual(test.project.get_project_guid(),
                             None, "Guid shouldn't be none!")
         self.assertEqual(options.Domain, test.project.domain)
+        self.assertEqual(
+            self.config["target_languages"], test.project.languages.target)
 
         test.delete()
 
@@ -323,6 +326,67 @@ class MemoQProjectTest(unittest.TestCase):
 
         test.delete()
 
+    def test_pretranslate_options(self):
+        """ Test for pretranslate_options method."""
+        test = memoQProject.MemoQProject()
+
+        fake_options = test.client.factory.create(
+            '{http://kilgray.com/memoqservices/2007}PretranslateOptions')
+        lookup_behavior = test.client.factory.create(
+            '{http://schemas.datacontract.org/2004/07/MemoQServices}PretranslateLookupBehavior')
+        fake_options.PretranslateLookupBehavior.value = lookup_behavior.GoodMatch
+        fake_options.GoodMatchRate = 80
+        fake_options.LockPretranslated = True
+
+        options = test.pretranslate_options()
+        self.assertEqual(
+            fake_options.PretranslateLookupBehavior.value, options.PretranslateLookupBehavior.value,
+            "Lookup behavior option shouldn't be different!")
+        self.assertEqual(fake_options.GoodMatchRate, options.GoodMatchRate,
+                         "Good Match option shouldn't be different!")
+        self.assertEqual(fake_options.LockPretranslated, options.LockPretranslated,
+                         "Lock Pretranslated options shouldn't be different!")
+
+    def test_pretranslate_project(self):
+        """ Test for pretranslate_project method."""
+        test = memoQProject.MemoQProject()
+        test.project.languages.source = self.config["source_language"]
+
+        test.create_project_from_template(
+            template_guid=self.config["project_template_guid"])
+
+        self.assertNotEqual(test.project.get_project_guid(),
+                            None, "Guid shouldn't be none!")
+
+        result = test.import_document(self.config["test_file_path"])
+        self.assertTrue(result, "Result should be true!")
+
+        self.assertTrue(test.pretranslate_project(),
+                        "Pre-translation shouldn't return false!")
+
+        test.delete()
+
+        # Testing override
+        test = memoQProject.MemoQProject()
+        test.project.languages.source = self.config["source_language"]
+
+        test.create_project_from_template(
+            template_guid=self.config["project_template_guid"])
+
+        self.assertNotEqual(test.project.get_project_guid(),
+                            None, "Guid shouldn't be none!")
+
+        result = test.import_document(self.config["test_file_path"])
+        self.assertTrue(result, "Result should be true!")
+
+        options = test.pretranslate_options()
+        options.GoodMatchRate = 90
+
+        self.assertTrue(test.pretranslate_project(options=options),
+                        "Pre-translation shouldn't return false!")
+
+        test.delete()
+
     def test_delete(self):
         """ Test for delete method."""
         test = memoQProject.MemoQProject()

memoQResource.py

@@ -17,7 +17,6 @@ class MemoQResource(object):
 
         self.types = self.client.factory.create(
             '{http://kilgray.com/memoqservices/2007}ResourceType')
-        self.guid = None
         self.__type = None
         self.info = None
 
@@ -27,30 +26,37 @@ class MemoQResource(object):
         else:
             return "No resource!"
 
+    def get_guid(self):
+        """Returns resource guid."""
+        if self.info != None:
+            return self.info.Guid
+
     def get_type(self):
         """Returns resource type."""
         return self.__type
 
+    def set_type(self, value):
+        """Sets resource type."""
+        if self.valid_type(value):
+            self.__type = self.types[value]
+
     def valid_type(self, value):
         """Returns true if type is valid."""
         if value in self.types:
             return True
         return False
 
-    def set_type(self, value):
-        """Sets resource type."""
-        if self.valid_type(value):
-            self.__type = self.types[value]
-
-    def set_active_resource(self, guid=None, resource_type=None):
+    def set_active_resource(self, guid, resource_type):
         """Populates info basing on resource type and guid."""
-        if resource_type != None and guid != None:
-            self.set_type(resource_type)
-            self.guid = guid
-
-        if self.guid != None and self.get_type() != None:
-            self.info = self.client.service.GetResourceInfo(
-                self.get_type(), self.guid)
+        if guid != None and self.valid_type(resource_type):
+            try:
+                info = self.client.service.GetResourceInfo(
+                    self.types[resource_type], guid)
+                if info != None:
+                    self.info = info
+                    self.set_type(resource_type)
+            except Exception:
+                pass
 
     def get_resources_of_type(self, resource_type):
         """Returns all resources of given type from memoQ server."""
@@ -67,7 +73,7 @@ class MemoQResource(object):
 
     def download_resource(self, path):
         """Downloads active resource to given path. Returns path to downloaded file."""
-        if self.get_type() != None and self.guid != None:
+        if self.get_type() != None and self.get_guid() != None:
             file_client = memoQFile.MemoQFile()
             return file_client.download_file(
-                path, self.client.service.ExportResource(self.get_type(), self.guid))
+                path, self.client.service.ExportResource(self.get_type(), self.get_guid()))

memoQResourceTest.py

@@ -38,23 +38,23 @@ class MemoQResourceTest(unittest.TestCase):
         """ Test for get_project_by_domain method."""
         test = memoQResource.MemoQResource()
 
-        test.set_active_resource()
+        test.set_active_resource(self.config["wrong_resource_guid"],
+                                 self.config["valid_resource_type"])
         self.assertEqual(
-            test.info, None, "Setting active resource for empty object should return none!")
+            test.info, None, "Setting active resource with wrong guid \
+            and valid type should return none!")
 
-        test.guid = self.config["valid_resource_guid"]
-        test.set_type(self.config["valid_resource_type"])
-        test.set_active_resource()
-        self.assertNotEqual(
+        test.set_active_resource(self.config["valid_resource_guid"],
+                                 self.config["wrong_resource_type"])
+        self.assertEqual(
             test.info, None, "Setting active resource with valid guid \
-            and type shouldn't return none! (feilds)")
+            and wrong type should return none!")
 
-        test = memoQResource.MemoQResource()
         test.set_active_resource(self.config["valid_resource_guid"],
                                  self.config["valid_resource_type"])
         self.assertNotEqual(
             test.info, None, "Setting active resource with valid guid \
-            and type shouldn't return none! (arguments)")
+            and type shouldn't return none!")
 
     def test_get_resources_of_type(self):
         """ Test for get_resources_of_type method."""

memoQTM.py

@@ -48,7 +48,7 @@ class MemoQTM(object):
             return None
 
     def set_active_tm(self, guid):
-        """Sets guid and info if TM exists."""
+        """Sets TM of given guid as active."""
         tm_info = self.get_tm_details(guid)
         if tm_info != None:
             self.tm = TM(tm_info)