SPPAS 4.20

def load_resources(self, config_filename, lang='und', **kwargs):
    """Fix the keys from a configuration file.

        :param config_filename: Name of the configuration file with the keys
        :param lang: (str) Iso639-3 of the language or "und" if unknown.

        """
    self.__lang = lang
    if lang != 'und':
        self.__cued.load(config_filename)
    self.__genkey = sppasWhatKeyPredictor(cue_rules=self.__cued)
    self.__genhand = sppasWhenHandTransitionPredictor(cue_rules=self.__cued, predictor_version=self._options['handtrans'])
    self.__gencue = sppasWhereCuePredictor(cue_rules=self.__cued)
    if self._options['createvideo'] is True:
        self.__set_video_tagger()

def fix_options(self, options):
    """Fix all options.

        Available options are:

            - handtrans: version of the hand transition estimator model
            - createvideo
            - handset

        :param options: (sppasOption)

        """
    for opt in options:
        key = opt.get_key()
        if 'createvideo' == key:
            self.set_create_video(opt.get_value())
        elif 'pattern' in key:
            self._options[key] = opt.get_value()
        elif 'handtrans' == key:
            self.set_when_handtrans_version(opt.get_value())
        elif self.__tagger is not None:
            self.__tagger.set_option(key, opt.get_value())

def set_when_handtrans_version(self, version=3):
    """Fix the version of the hand transition generator.

        :param version: (int)

        """
    all_versions = self.__genhand.get_whenpredictor_versions()
    version = int(version)
    if version not in all_versions:
        msg = "Invalid version number '{}'. Expected one of {}".format(version, all_versions)
        self.logfile.print_message(msg, status=annots.error)
        version = 3
    self.__genhand.set_whenpredictorr_version(version)
    self._options['handtrans'] = version

def set_create_video(self, create=True):
    """Fix the createvideo option.

        :param create: (bool)

        """
    create = bool(create)
    self._options['createvideo'] = create
    if create is True:
        self.__set_video_tagger()
    else:
        self.__tagger = None

def convert(self, phonemes, media):
    """Syllabify labels of a time-aligned phones tier.

        :param phonemes: (sppasTier) time-aligned phonemes tier
        :param media: (sppasMedia) a media representing the video file
        :returns: (sppasTier*6)

        """
    cs_segments = self.__genkey.phons_to_segments(phonemes)
    cs_keys, cs_class, cs_struct = self.__genkey.segments_to_keys(cs_segments, phonemes.get_first_point(), phonemes.get_last_point())
    cs_pos, cs_shapes = self.__genhand.when_hands(cs_keys, cs_segments)
    return (cs_segments, cs_keys, cs_class, cs_struct, cs_shapes, cs_pos)

def make_video(self, video_file, trs, output):
    """Create a video with the tagged keys.

        :param video_file: (str) Filename of the given video
        :param trs: (sppasTranscription) All required tiers to tag the video
        :param output: (str) Output file name

        """
    if cfg.feature_installed('video') is True:
        self.logfile.print_message('Create the tagged video', status=annots.info)
        self.__tagger.load(video_file)
        self.__tagger.tag_with_keys(trs, output)
        self.__tagger.close()
    else:
        self.logfile.print_message('To tag a video, the video support feature must be enabled.', status=annots.error)

def get_inputs(self, input_files):
    """Return the media and the annotated filenames.

        :param input_files: (list)
        :raise: NoInputError
        :return: (str, str) Names of the 3 expected files

        """
    ext = self.get_input_extensions()
    media_ext = [e.lower() for e in ext[1]]
    phons_ext = [e.lower() for e in ext[0]]
    sights_ext = [e.lower() for e in ext[2]]
    media = None
    annot_phons = None
    annot_sights = None
    pphones = self._options['inputpattern1']
    psights = self._options['inputpattern3']
    for filename in input_files:
        if filename is None:
            continue
        fn, fe = os.path.splitext(filename)
        if media is None and fe in media_ext:
            media = filename
        elif annot_phons is None and fe.lower() in phons_ext and fn.endswith(pphones):
            annot_phons = filename
        elif annot_sights is None and fe.lower() in sights_ext and fn.endswith(psights):
            annot_sights = filename
    if annot_phons is None:
        logging.error('The annotated file with time-aligned phonemes was not found.')
        raise NoInputError
    return (media, annot_phons, annot_sights)

def create_media(self, video_filename):
    """Create a sppasMedia() instance from a video filename.

        """
    if video_filename is None:
        return None
    extm = os.path.splitext(video_filename.lower())[1]
    video_media = sppasMedia(os.path.abspath(video_filename), mime_type='video/' + extm)
    try:
        vid = sppasVideoReader()
        vid.open(video_filename)
        video_media.set_meta('fps', str(vid.get_framerate()))
        video_media.set_meta('duration', str(vid.get_duration()))
        video_media.set_meta('size', str(vid.get_size()))
        vid.close()
    except:
        pass
    return video_media

def run(self, input_files, output=None):
    """Run the automatic annotation process on an input.

        :param input_files: (list of str) time-aligned phonemes, and optionally video, csv files
        :param output: (str) the output name
        :returns: (sppasTranscription)

        """
    try:
        do_vid = False
        file_video, file_phons, file_sights = self.get_inputs(input_files)
        video_media = self.create_media(file_video)
        parser = sppasTrsRW(file_phons)
        trs_input = parser.read()
        tier_phon = sppasFindTier.aligned_phones(trs_input)
        trs_output = sppasTranscription(self.name)
        self._set_trs_metadata(trs_output, file_phons)
        tier_cs, tier_key, tier_class, tier_struct, tier_shapes_transitions, tier_pos_transitions = self.convert(tier_phon, video_media)
        trs_output.append(tier_cs)
        trs_output.append(tier_struct)
        trs_output.append(tier_key)
        trs_output.append(tier_class)
        trs_output.append(tier_shapes_transitions)
        trs_output.append(tier_pos_transitions)
        trs_coords = sppasTranscription(self.name)
        self._set_trs_metadata(trs_coords, file_phons)
        if file_sights is not None:
            if video_media is not None:
                trs_coords.add_media(video_media)
                adjusted_pos = tier_pos_transitions.copy()
                self._set_media_to_tier(adjusted_pos, video_media, adjust=True)
                trs_coords.append(adjusted_pos)
                adjusted_shapes = tier_shapes_transitions.copy()
                self._set_media_to_tier(adjusted_shapes, video_media, adjust=True)
                trs_coords.append(adjusted_shapes)
                trs_coords = self.__gencue.predict_where(file_sights, adjusted_pos, adjusted_shapes)
            else:
                trs_coords = self.__gencue.predict_where(file_sights, tier_pos_transitions, tier_shapes_transitions)
            trs_coords.append(tier_phon)
            for tier in trs_coords:
                self._set_media_to_tier(tier, video_media, adjust=False)
            if self._options['createvideo']:
                if len(input_files) > 2:
                    if file_video is not None and file_sights is not None:
                        do_vid = True
                        self.make_video(file_video, trs_coords, output)
                if do_vid is False:
                    self.logfile.print_message('The option to tag the video was enabled but no video/csv corresponding to the annotated file {:s} was found.'.format(input_files[0]), status=-1)
        else:
            logging.info('No sights available.')
        if output is None:
            return trs_output
        outputs = list()
        output_file = self.fix_out_file_ext(output)
        if len(trs_output) > 0:
            parser = sppasTrsRW(output_file)
            parser.write(trs_output)
            outputs.append(output_file)
        else:
            raise EmptyOutputError
        if output is not None:
            coords_output = output_file.replace(self.get_output_pattern(), '-coords')
            parser = sppasTrsRW(coords_output)
            parser.write(trs_coords)
            outputs.append(coords_output)
    except Exception as e:
        import traceback
        traceback.print_exception(e)
        raise
    return outputs

def get_output_pattern(self):
    """Pattern this annotation uses in an output filename."""
    return self._options.get('outputpattern', '-cuedspeech')

def get_input_patterns(self):
    """Pattern this annotation expects for its input filename."""
    return [self._options.get('inputpattern1', '-palign'), self._options.get('inputpattern2', ''), self._options.get('inputpattern3', '-sights')]

@staticmethod
def get_input_extensions():
    """Extensions that the annotation expects for its input filename."""
    return [sppasFiles.get_informat_extensions('ANNOT_ANNOT'), sppasFiles.get_informat_extensions('VIDEO'), ['.xra', '.csv']]

@staticmethod
def get_hands_sets() -> List[str]:
    """List of all hands sets in the resources.cuedspeech folder.

        :return: (list[str]) A list of all hands sets available.

        """
    hand_manager = sppasHandResource()
    hand_manager.automatic_loading()
    return hand_manager.get_hand_sets_identifiers()

@staticmethod
def get_hands_filters() -> List[str]:
    """List of all hands filters available.

        :return: (list[str]) A list of all hands filters.

        """
    return ['cartoon', 'sights', 'skeleton']

def _set_media_to_tier(self, tier, media, adjust=False):
    """Set the media to the tier and adjust annotation boundaries.

        """
    if media is None:
        return
    tier.set_media(media)
    fps = media.get_meta('fps', None)
    if fps is not None and adjust is True:
        self.__ann_on_media.fps = fps
        self.__ann_on_media.adjust_boundaries(tier)

def _set_trs_metadata(self, trs, filename):
    trs.set_meta('annotation_result_of', filename)
    trs.set_meta('language_iso', 'iso639-3')
    trs.set_meta('language_name_0', 'Undetermined')
    if len(self.__lang) == 3:
        trs.set_meta('language_code_0', self.__lang)
        trs.set_meta('language_url_0', 'https://iso639-3.sil.org/code/' + self.__lang)
    else:
        trs.set_meta('language_code_0', 'und')
        trs.set_meta('language_url_0', 'https://iso639-3.sil.org/code/und')

def __set_video_tagger(self):
    try:
        if self.__tagger is None:
            self.__tagger = CuedSpeechVideoTagger(cue_rules=self.__cued)
        else:
            self.__tagger.set_cue_rules(self.__cued)
    except sppasEnableFeatureError as e:
        self.__tagger = None
        logging.warning("Cued Speech Video Tagger can't be enabled: {:s}".format(str(e)))