예제 #1
0
 def test_wizard_analyze_valid(self):
     f = self.FILES[0]
     analyzer = AnalyzeContainer(
         Container(gf.absolute_path(f["path"], __file__)))
     job = analyzer.analyze(config_string=self.CONFIG_STRING)
     self.assertIsNotNone(job)
     self.assertEqual(len(job), f["length"])
예제 #2
0
    def check_container(self, container_path, container_format=None, config_string=None):
        """
        Check whether the given container is well-formed.

        :param string container_path: the path of the container to be checked
        :param container_format: the format of the container
        :type  container_format: :class:`~aeneas.container.ContainerFormat`
        :param string config_string: the configuration string generated by the wizard
        :rtype: :class:`~aeneas.validator.ValidatorResult`
        """
        self.log([u"Checking container '%s'", container_path])
        self.result = ValidatorResult()

        if self._are_safety_checks_disabled(u"check_container"):
            return self.result

        if not (gf.file_exists(container_path) or gf.directory_exists(container_path)):
            self._failed(u"Container '%s' not found." % container_path)
            return self.result

        container = Container(container_path, container_format)
        try:
            self.log(u"Checking container has config file")
            if config_string is not None:
                self.log(u"Container with config string from wizard")
                self.check_config_txt(config_string, is_config_string=True)
            elif container.has_config_xml:
                self.log(u"Container has XML config file")
                contents = container.read_entry(container.entry_config_xml)
                if contents is None:
                    self._failed(u"Unable to read the contents of XML config file.")
                    return self.result
                self.check_config_xml(contents)
            elif container.has_config_txt:
                self.log(u"Container has TXT config file")
                contents = container.read_entry(container.entry_config_txt)
                if contents is None:
                    self._failed(u"Unable to read the contents of TXT config file.")
                    return self.result
                self.check_config_txt(contents, is_config_string=False)
            else:
                self._failed(u"Container does not have a TXT or XML configuration file.")

            self.log(u"Checking we have a valid job in the container")
            if not self.result.passed:
                return self.result
            self.log(u"Analyze the contents of the container")
            analyzer = AnalyzeContainer(container)
            if config_string is not None:
                job = analyzer.analyze(config_string=config_string)
            else:
                job = analyzer.analyze()
            self._check_analyzed_job(job, container)

        except OSError:
            self._failed(u"Unable to read the contents of the container.")
        return self.result
예제 #3
0
파일: validator.py 프로젝트: fduch2k/aeneas
    def _check_container_with_txt_config_string(
            self,
            container,
            config_string=None
        ):
        """
        Check whether the given container with TXT (INI-like)
        configuration is well-formed.

        :param container: the container
        :type  container: Container
        :param config_string: the TXT (INI-like) configuration string
        :type  config_string: string
        :rtype: :class:`aeneas.validator.ValidatorResult`
        """
        self._log("Checking container with TXT config file")

        result = ValidatorResult()
        # if no config string was passed, try to read it from container
        if config_string is None:
            self._log("Trying to read config file from container")
            config_in_container = True
            config_contents = container.read_entry(container.entry_config_txt)
            if config_contents is None:
                msg = "Unable to read the contents of TXT config file."
                result.passed = False
                result.add_error(msg)
                self._log(msg)
                return result
            self._log("Config file found in container")
        else:
            self._log("Config string passed as parameter")
            config_contents = config_string
            config_in_container = False

        # check the txt config contents or string
        result = self.check_contents_txt_config_file(
            config_contents,
            config_in_container
        )
        if not result.passed:
            self._log("Failed")
            return result

        # analyze the container
        self._log("Analyze the contents of the container")
        analyzer = AnalyzeContainer(container)
        if config_in_container:
            job = analyzer.analyze()
        else:
            job = analyzer.analyze_from_wizard(config_string)
        self._check_analyzed_job(job, container, result)

        # return result
        self._log(["Checking container with TXT config file: returning %s", result.passed])
        return result
예제 #4
0
파일: validator.py 프로젝트: fduch2k/aeneas
    def _check_container_with_txt_config_string(self,
                                                container,
                                                config_string=None):
        """
        Check whether the given container with TXT (INI-like)
        configuration is well-formed.

        :param container: the container
        :type  container: Container
        :param config_string: the TXT (INI-like) configuration string
        :type  config_string: string
        :rtype: :class:`aeneas.validator.ValidatorResult`
        """
        self._log("Checking container with TXT config file")

        result = ValidatorResult()
        # if no config string was passed, try to read it from container
        if config_string is None:
            self._log("Trying to read config file from container")
            config_in_container = True
            config_contents = container.read_entry(container.entry_config_txt)
            if config_contents is None:
                msg = "Unable to read the contents of TXT config file."
                result.passed = False
                result.add_error(msg)
                self._log(msg)
                return result
            self._log("Config file found in container")
        else:
            self._log("Config string passed as parameter")
            config_contents = config_string
            config_in_container = False

        # check the txt config contents or string
        result = self.check_contents_txt_config_file(config_contents,
                                                     config_in_container)
        if not result.passed:
            self._log("Failed")
            return result

        # analyze the container
        self._log("Analyze the contents of the container")
        analyzer = AnalyzeContainer(container)
        if config_in_container:
            job = analyzer.analyze()
        else:
            job = analyzer.analyze_from_wizard(config_string)
        self._check_analyzed_job(job, container, result)

        # return result
        self._log([
            "Checking container with TXT config file: returning %s",
            result.passed
        ])
        return result
예제 #5
0
파일: validator.py 프로젝트: fduch2k/aeneas
    def _check_container_with_xml_config(
            self,
            container,
            config_contents=None
        ):
        """
        Check whether the given container with XML configuration is well-formed.

        :param container: the container
        :type  container: Container
        :param config_contents: the contents of the XML config file
        :type  config_contents: string
        :rtype: :class:`aeneas.validator.ValidatorResult`
        """
        self._log("Checking container with XML config file")

        result = ValidatorResult()
        # if no config contents was passed, try to read them from container
        if config_contents is None:
            self._log("Trying to read config file from container")
            config_contents = container.read_entry(container.entry_config_xml)
            if config_contents is None:
                msg = "Unable to read the contents of XML config file."
                result.passed = False
                result.add_error(msg)
                self._log(msg)
                return result

        # check the txt config contents or string
        result = self.check_contents_xml_config_file(config_contents)
        if not result.passed:
            self._log("Failed")
            return result

        # analyze the container
        self._log("Analyze the contents of the container")
        analyzer = AnalyzeContainer(container)
        job = analyzer.analyze()
        self._check_analyzed_job(job, container, result)

        # return result
        self._log(["Checking container: returning %s", result.passed])
        return result
예제 #6
0
파일: validator.py 프로젝트: fduch2k/aeneas
    def _check_container_with_xml_config(self,
                                         container,
                                         config_contents=None):
        """
        Check whether the given container with XML configuration is well-formed.

        :param container: the container
        :type  container: Container
        :param config_contents: the contents of the XML config file
        :type  config_contents: string
        :rtype: :class:`aeneas.validator.ValidatorResult`
        """
        self._log("Checking container with XML config file")

        result = ValidatorResult()
        # if no config contents was passed, try to read them from container
        if config_contents is None:
            self._log("Trying to read config file from container")
            config_contents = container.read_entry(container.entry_config_xml)
            if config_contents is None:
                msg = "Unable to read the contents of XML config file."
                result.passed = False
                result.add_error(msg)
                self._log(msg)
                return result

        # check the txt config contents or string
        result = self.check_contents_xml_config_file(config_contents)
        if not result.passed:
            self._log("Failed")
            return result

        # analyze the container
        self._log("Analyze the contents of the container")
        analyzer = AnalyzeContainer(container)
        job = analyzer.analyze()
        self._check_analyzed_job(job, container, result)

        # return result
        self._log(["Checking container: returning %s", result.passed])
        return result
예제 #7
0
 def test_container_not_existing(self):
     analyzer = AnalyzeContainer(Container(self.NOT_EXISTING_PATH))
     job = analyzer.analyze()
     self.assertIsNone(job)
예제 #8
0
 def test_not_container(self):
     with self.assertRaises(TypeError):
         analyzer = AnalyzeContainer(self.NOT_EXISTING_PATH)
예제 #9
0
 def test_check_container_xml_03(self):
     container_path = get_abs_path("res/validator/job_xml_config_not_root_nested")
     logger = Logger()
     analyzer = AnalyzeContainer(Container(container_path), logger=logger)
     job = analyzer.analyze()
     self.assertEqual(len(job), 3)
예제 #10
0
    def load_job_from_container(self, container_path, config_string=None):
        """
        Load the job from the given :class:`aeneas.container.Container` object.

        If ``config_string`` is ``None``,
        the container must contain a configuration file;
        otherwise use the provided config string
        (i.e., the wizard case).

        :param string container_path: the path to the input container
        :param string config_string: the configuration string (from wizard)
        :raises: :class:`~aeneas.executejob.ExecuteJobInputError`: if the given container does not contain a valid :class:`~aeneas.job.Job`
        """
        self.log(u"Loading job from container...")

        # create working directory where the input container
        # will be decompressed
        self.working_directory = gf.tmp_directory(root=self.rconf[RuntimeConfiguration.TMP_PATH])
        self.log([u"Created working directory '%s'", self.working_directory])

        try:
            self.log(u"Decompressing input container...")
            input_container = Container(container_path, logger=self.logger)
            input_container.decompress(self.working_directory)
            self.log(u"Decompressing input container... done")
        except Exception as exc:
            self.clean()
            self.log_exc(u"Unable to decompress container '%s': %s" % (container_path, exc), None, True, ExecuteJobInputError)

        try:
            self.log(u"Creating job from working directory...")
            working_container = Container(
                self.working_directory,
                logger=self.logger
            )
            analyzer = AnalyzeContainer(working_container, logger=self.logger)
            self.job = analyzer.analyze(config_string=config_string)
            self.log(u"Creating job from working directory... done")
        except Exception as exc:
            self.clean()
            self.log_exc(u"Unable to analyze container '%s': %s" % (container_path, exc), None, True, ExecuteJobInputError)

        if self.job is None:
            self.log_exc(u"The container '%s' does not contain a valid Job" % (container_path), None, True, ExecuteJobInputError)

        try:
            # set absolute path for text file and audio file
            # for each task in the job
            self.log(u"Setting absolute paths for tasks...")
            for task in self.job.tasks:
                task.text_file_path_absolute = gf.norm_join(
                    self.working_directory,
                    task.text_file_path
                )
                task.audio_file_path_absolute = gf.norm_join(
                    self.working_directory,
                    task.audio_file_path
                )
            self.log(u"Setting absolute paths for tasks... done")

            self.log(u"Loading job from container: succeeded")
        except Exception as exc:
            self.clean()
            self.log_exc(u"Error while setting absolute paths for tasks", exc, True, ExecuteJobInputError)
예제 #11
0
 def test_wizard_analyze_valid(self):
     f = self.FILES[0]
     analyzer = AnalyzeContainer(Container(gf.absolute_path(f["path"], __file__)))
     job = analyzer.analyze(config_string=self.CONFIG_STRING)
     self.assertIsNotNone(job)
     self.assertEqual(len(job), f["length"])
예제 #12
0
 def test_wizard_container_not_existing(self):
     analyzer = AnalyzeContainer(Container(self.NOT_EXISTING_PATH))
     job = analyzer.analyze(config_string=u"foo")
     self.assertIsNone(job)
예제 #13
0
 def test_analyze_empty_container(self):
     for f in self.EMPTY_CONTAINERS:
         analyzer = AnalyzeContainer(Container(f))
         job = analyzer.analyze()
         self.assertIsNone(job)
예제 #14
0
 def test_container_not_existing(self):
     analyzer = AnalyzeContainer(Container(self.NOT_EXISTING_PATH))
     job = analyzer.analyze()
     self.assertIsNone(job)
예제 #15
0
    def load_job_from_container(self, container_path, config_string=None):
        """
        Load the job from the given :class:`aeneas.container.Container` object.

        If ``config_string`` is ``None``,
        the container must contain a configuration file;
        otherwise use the provided config string
        (i.e., the wizard case).

        :param string container_path: the path to the input container
        :param string config_string: the configuration string (from wizard)
        :raises: :class:`~aeneas.executejob.ExecuteJobInputError`: if the given container does not contain a valid :class:`~aeneas.job.Job`
        """
        self.log(u"Loading job from container...")

        # create working directory where the input container
        # will be decompressed
        self.working_directory = gf.tmp_directory(
            root=self.rconf[RuntimeConfiguration.TMP_PATH])
        self.log([u"Created working directory '%s'", self.working_directory])

        try:
            self.log(u"Decompressing input container...")
            input_container = Container(container_path, logger=self.logger)
            input_container.decompress(self.working_directory)
            self.log(u"Decompressing input container... done")
        except Exception as exc:
            self.clean()
            self.log_exc(
                u"Unable to decompress container '%s': %s" %
                (container_path, exc), None, True, ExecuteJobInputError)

        try:
            self.log(u"Creating job from working directory...")
            working_container = Container(self.working_directory,
                                          logger=self.logger)
            analyzer = AnalyzeContainer(working_container, logger=self.logger)
            self.job = analyzer.analyze(config_string=config_string)
            self.log(u"Creating job from working directory... done")
        except Exception as exc:
            self.clean()
            self.log_exc(
                u"Unable to analyze container '%s': %s" %
                (container_path, exc), None, True, ExecuteJobInputError)

        if self.job is None:
            self.log_exc(
                u"The container '%s' does not contain a valid Job" %
                (container_path), None, True, ExecuteJobInputError)

        try:
            # set absolute path for text file and audio file
            # for each task in the job
            self.log(u"Setting absolute paths for tasks...")
            for task in self.job.tasks:
                task.text_file_path_absolute = gf.norm_join(
                    self.working_directory, task.text_file_path)
                task.audio_file_path_absolute = gf.norm_join(
                    self.working_directory, task.audio_file_path)
            self.log(u"Setting absolute paths for tasks... done")

            self.log(u"Loading job from container: succeeded")
        except Exception as exc:
            self.clean()
            self.log_exc(u"Error while setting absolute paths for tasks", exc,
                         True, ExecuteJobInputError)
예제 #16
0
 def test_analyze_empty_container(self):
     for f in self.EMPTY_CONTAINERS:
         analyzer = AnalyzeContainer(Container(f))
         job = analyzer.analyze()
         self.assertIsNone(job)
예제 #17
0
 def test_analyze(self):
     for f in self.FILES:
         analyzer = AnalyzeContainer(Container(gf.absolute_path(f["path"], __file__)))
         job = analyzer.analyze()
         self.assertEqual(len(job), f["length"])
예제 #18
0
 def test_analyze(self):
     for f in self.FILES:
         analyzer = AnalyzeContainer(
             Container(gf.absolute_path(f["path"], __file__)))
         job = analyzer.analyze()
         self.assertEqual(len(job), f["length"])
예제 #19
0
 def test_wizard_analyze_empty_container(self):
     for f in self.EMPTY_CONTAINERS:
         analyzer = AnalyzeContainer(Container(f))
         job = analyzer.analyze(config_string=u"foo")
         self.assertIsNone(job)
예제 #20
0
 def test_wizard_container_not_existing(self):
     analyzer = AnalyzeContainer(Container(self.NOT_EXISTING_PATH))
     job = analyzer.analyze(config_string=u"foo")
     self.assertIsNone(job)
예제 #21
0
    def load_job_from_container(self, container_path, config_string=None):
        """
        Validate the given container, and, if it is well formed,
        load the job from it.

        If ``config_string`` is ``None``,
        the container must contain a configuration file;
        otherwise use the provided config string
        (i.e., the wizard case).

        Return ``True`` if the job has been loaded successfully,
        ``False`` otherwise.

        :param container_path: the path to the input container
        :type  container_path: string (path)
        :param config_string: the configuration string (from wizard)
        :type  config_string: string
        :rtype: bool
        """
        self._log("Loading job from container...")

        # validate container
        self._log("Validating container...")
        validator = Validator(logger=self.logger)
        if config_string is None:
            validator_result = validator.check_container(container_path)
        else:
            validator_result = validator.check_container_from_wizard(
                container_path, config_string)
        if not validator_result.passed:
            self._log("Validating container: failed")
            self._log("Loading job from container: failed")
            return False
        self._log("Validating container: succeeded")

        try:
            # create working directory where the input container
            # will be decompressed
            self.working_directory = tempfile.mkdtemp(dir=gf.custom_tmp_dir())
            self._log(
                ["Created working directory '%s'", self.working_directory])

            # decompress
            self._log("Decompressing input container...")
            input_container = Container(container_path, logger=self.logger)
            input_container.decompress(self.working_directory)
            self._log("Decompressing input container... done")

            # create job from the working directory
            self._log("Creating job from working directory...")
            working_container = Container(self.working_directory,
                                          logger=self.logger)
            analyzer = AnalyzeContainer(working_container, logger=self.logger)
            if config_string is None:
                self.job = analyzer.analyze()
            else:
                self.job = analyzer.analyze_from_wizard(config_string)
            self._log("Creating job from working directory... done")

            # set absolute path for text file and audio file
            # for each task in the job
            self._log("Setting absolute paths for tasks...")
            for task in self.job.tasks:
                task.text_file_path_absolute = gf.norm_join(
                    self.working_directory, task.text_file_path)
                task.audio_file_path_absolute = gf.norm_join(
                    self.working_directory, task.audio_file_path)
            self._log("Setting absolute paths for tasks... done")

            # return
            self._log("Loading job from container: succeeded")
            return True
        except:
            # failure: clean and return
            self.clean()
            self._log("Loading job from container: failed")
            return False
예제 #22
0
 def test_wizard_analyze_empty_container(self):
     for f in self.EMPTY_CONTAINERS:
         analyzer = AnalyzeContainer(Container(f))
         job = analyzer.analyze(config_string=u"foo")
         self.assertIsNone(job)
예제 #23
0
파일: executejob.py 프로젝트: dburt/aeneas
    def load_job_from_container(self, container_path, config_string=None):
        """
        Validate the given container, and, if it is well formed,
        load the job from it.

        If ``config_string`` is ``None``,
        the container must contain a configuration file;
        otherwise use the provided config string
        (i.e., the wizard case).

        Return ``True`` if the job has been loaded successfully,
        ``False`` otherwise.

        :param container_path: the path to the input container
        :type  container_path: string (path)
        :param config_string: the configuration string (from wizard)
        :type  config_string: string
        :rtype: bool
        """
        self._log("Loading job from container...")

        # validate container
        self._log("Validating container...")
        validator = Validator(logger=self.logger)
        if config_string == None:
            validator_result = validator.check_container(container_path)
        else:
            validator_result = validator.check_container_from_wizard(
                container_path,
                config_string
            )
        if not validator_result.passed:
            self._log("Validating container: failed")
            self._log("Loading job from container: failed")
            return False
        self._log("Validating container: succeeded")

        try:
            # create working directory where the input container
            # will be decompressed
            self.working_directory = tempfile.mkdtemp(dir=gf.custom_tmp_dir())
            self._log("Created working directory '%s'" % self.working_directory)

            # decompress
            self._log("Decompressing input container...")
            input_container = Container(container_path, logger=self.logger)
            input_container.decompress(self.working_directory)
            self._log("Decompressing input container... done")

            # create job from the working directory
            self._log("Creating job from working directory...")
            working_container = Container(
                self.working_directory,
                logger=self.logger
            )
            analyzer = AnalyzeContainer(working_container, logger=self.logger)
            if config_string == None:
                self.job = analyzer.analyze()
            else:
                self.job = analyzer.analyze_from_wizard(config_string)
            self._log("Creating job from working directory... done")

            # set absolute path for text file and audio file
            # for each task in the job
            self._log("Setting absolute paths for tasks...")
            for task in self.job.tasks:
                task.text_file_path_absolute = gf.norm_join(
                    self.working_directory,
                    task.text_file_path
                )
                task.audio_file_path_absolute = gf.norm_join(
                    self.working_directory,
                    task.audio_file_path
                )
            self._log("Setting absolute paths for tasks... done")

            # return
            self._log("Loading job from container: succeeded")
            return True
        except:
            # failure: clean and return
            self.clean()
            self._log("Loading job from container: failed")
            return False
예제 #24
0
 def test_none(self):
     with self.assertRaises(TypeError):
         analyzer = AnalyzeContainer(None)
예제 #25
0
 def test_analyze(self):
     for f in self.FILES:
         analyzer = AnalyzeContainer(Container(get_abs_path(f["path"])))
         job = analyzer.analyze()
         self.assertEqual(len(job), f["length"])
예제 #26
0
 def test_check_container_txt_paged_03(self):
     container_path = get_abs_path("res/validator/job_txt_config_paged_3")
     logger = Logger()
     analyzer = AnalyzeContainer(Container(container_path), logger=logger)
     job = analyzer.analyze()
     self.assertEqual(len(job), 3)