xslsetter

Get and set metadata in metadata files.

MetadataHandler

Class to handle metadata in .xsl files.

This class makes the xsl file

Source code in corpustools/xslsetter.py

class MetadataHandler:
    """Class to handle metadata in .xsl files.

    This class makes the xsl file
    """

    lang_key = "{http://www.w3.org/XML/1998/namespace}lang"

    def __init__(self, filename: Path, create: bool = False):
        """Initialise the MetadataHandler class.

        Args:
            filename: path to the metadata file.
            create (bool): Define if a MetadataHandler will be created from a
                metadata file belonging to a original file inside the corpus or
                created from a template file containing default values.

                If false, try to read a metadata file, and create a
                MetadataHandler from this. If the file does not exist, raise a
                util.ArgumentError.

                If True, create a new MetadataHandler with default values
                from the template file.

        Raises:
            util.ArgumentError:if create is False and the filename does not
                exist.
            XsltException: if there is a syntax error in the metadata file.
        """
        self.filename = filename

        if not filename.exists():
            if not create:
                raise util.ArgumentError(f"{filename} does not exist!")
            self.tree = etree.parse(here / "xslt/XSL-template.xsl")
        else:
            try:
                self.tree = etree.parse(filename)
            except etree.XMLSyntaxError as error:
                raise XsltError(f"Syntax error in {self.filename}:\n{error}") from error

    def _get_variable_elt(self, key: str) -> etree.Element | None:
        """Get the variable element.

        Args:
            key: The name of the variable that should be looked up.

        Returns:
            The element that contains the key.
        """

        return self.tree.getroot().find(
            "{{http://www.w3.org/1999/XSL/Transform}}variable[@name='{}']".format(key)
        )

    def set_variable(self, key: str, value: str):
        """Set the value of a variable.

        Args:
            key: Name of the variable to set.
            value: The value the variable should be set to.
        """
        try:
            variable = self._get_variable_elt(key)
            if variable is None:
                variable = self.make_xsl_variable(key)
            variable.attrib["select"] = f"'{value}'"
        except AttributeError as error:
            raise UserWarning(
                "Tried to update {} with value {}\nError was {}".format(
                    key, value, str(error)
                )
            ) from error

    def get_variable(self, key: str) -> str | None:
        """Get the value associated with the key.

        Args:
            key: Name of the variable to get.

        Returns:
            (str|None): The string contains the value associated with the key.
        """
        variable = self._get_variable_elt(key)
        if variable is not None:
            value = variable.attrib["select"]
            clean_value = value.replace("'", "")
            if clean_value:
                return clean_value

        return None

    def get_set_variables(self):
        """Find all set variables.

        Yields:
            (tuple[str, Any]): a key/value pair
        """
        ns = {"xsl": "http://www.w3.org/1999/XSL/Transform"}
        for variable in self.tree.getroot().xpath(
            ".//xsl:variable[@select]", namespaces=ns
        ):
            value = self.get_variable(variable.get("name"))
            if value is not None and value.strip():
                yield variable.get("name"), value

    def get_parallel_texts(self) -> dict[str, str]:
        """Get the parallel texts.

        Returns:
            A dict of parallel files containing language:filename pairs.
        """
        parallels = self._get_variable_elt("parallels")
        if parallels is None:
            return {}
        else:
            elts = parallels.findall("parallel_text")
            return {
                p.attrib[self.lang_key]: p.attrib["location"].strip("'")
                for p in elts
                if p.attrib["location"].strip("'") != ""
            }

    @property
    def mlangs(self) -> set[str]:
        """Get the languages to look for in the document.

        Returns:
            A set of languages to look for in the document
        """
        mlangs = self._get_variable_elt("mlangs")
        if mlangs is None:
            return set()
        else:
            return {
                mlang.get(self.lang_key, "") for mlang in mlangs.findall("language")
            }

    def make_xsl_variable(self, name: str) -> etree.Element:
        elt = etree.Element("{http://www.w3.org/1999/XSL/Transform}variable", name=name)
        self.tree.getroot().append(elt)

        return elt

    def set_mlang(self, language: str):
        """Set a language in mlangs.

        Args:
            language: a language code that should be set.
        """
        mlangs = self._get_variable_elt("mlangs")
        if mlangs is None:
            mlangs = self.make_xsl_variable("mlangs")

        if language not in self.mlangs:
            mlang = etree.Element("language")
            mlang.attrib.update({self.lang_key: language})
            mlangs.append(mlang)

    def set_parallel_text(self, language: str, location: str):
        """Insert the name of a parallel file into the parallels element.

        Args:
            language: the language of the parallel file.
            location: the name of the parallel file.
        """
        attrib = {self.lang_key: language, "location": location}
        parallels = self._get_variable_elt("parallels")
        if parallels is None:
            parallels = self.make_xsl_variable("parallels")

        elt = parallels.find(f"parallel_text[@{self.lang_key}='{language}']")
        if elt is not None:
            elt.attrib.update(attrib)
        else:
            elt = etree.Element("parallel_text", attrib=attrib)
            elt.tail = "\n"
            parallels.append(elt)

    @property
    def skip_pages(self) -> list[int | str]:
        """Turn a skip_pages entry into a list of pages.

        Returns:
            The list can contain the strings 'all', 'even' and 'odd' or specific page
            numbers as integers.
        """
        pages: list[int | str] = []
        skip_pages = self.get_variable("skip_pages")
        if skip_pages is not None:
            if "odd" in skip_pages and "even" in skip_pages:
                raise XsltError(
                    'Invalid format: Cannot have both "even" and "odd" in this line\n'
                    "{}".format(skip_pages)
                )

            if "odd" in skip_pages:
                pages.append("odd")
                skip_pages = skip_pages.replace("odd", "")
            if "even" in skip_pages:
                pages.append("even")
                skip_pages = skip_pages.replace("even", "")

            # Turn single pages into single-page ranges, e.g. 7 → 7-7
            skip_ranges_norm = (
                (r if "-" in r else r + "-" + r)
                for r in skip_pages.strip().split(",")
                if r != ""
            )

            skip_ranges = (tuple(map(int, r.split("-"))) for r in skip_ranges_norm)

            try:
                pages.extend(
                    [
                        page
                        for start, end in sorted(skip_ranges)
                        for page in range(start, end + 1)
                    ]
                )

            except ValueError as error:
                raise XsltError(f"Invalid format: {skip_pages}") from error

        return pages

    @property
    def skip_lines(self) -> list[int]:
        """Turn a skip_lines entry into a list of lines.

        Returns:
            list (int): list of line to skip numbers as integers.
        """
        lines: list[int] = []
        skip_lines = self.get_variable("skip_lines")
        if skip_lines is not None:
            # Turn single lines into single-page ranges, e.g. 7 → 7-7
            skip_ranges_norm = (
                (r if "-" in r else r + "-" + r)
                for r in skip_lines.strip().split(",")
                if r != ""
            )

            skip_ranges = (tuple(map(int, r.split("-"))) for r in skip_ranges_norm)

            try:
                lines.extend(
                    [
                        line
                        for start, end in sorted(skip_ranges)
                        for line in range(start, end + 1)
                    ]
                )

            except ValueError as error:
                raise XsltError(f"Invalid format: {skip_lines}") from error

        return lines

    @property
    def epub_excluded_chapters(self) -> list[int]:
        """Turn a skip_lines entry into a list of lines.

        Returns:
            list (int): list of line to skip numbers as integers.
        """
        lines: list[int] = []
        chosen = self.get_variable("epub_excluded_chapters")
        if chosen is not None:
            # Turn single lines into single-page ranges, e.g. 7 → 7-7
            skip_ranges_norm = (
                (r if "-" in r else r + "-" + r)
                for r in chosen.strip().split(",")
                if r != ""
            )

            skip_ranges = (tuple(map(int, r.split("-"))) for r in skip_ranges_norm)

            try:
                lines.extend(
                    [
                        line
                        for start, end in sorted(skip_ranges)
                        for line in range(start, end + 1)
                    ]
                )

            except ValueError as error:
                raise XsltError(f"Invalid format: {chosen}") from error

        return lines

    def get_margin_lines(self, position: str = "") -> dict[str, str]:
        """Get the margin lines from the metadata file.

        Args:
            position: empty if getting regular margin lines,
                otherwise inner_ if getting inner margin lines.

        Returns:
            A dictionary of margin name to percentages
        """
        margin_lines = {
            key: self.get_variable(key).strip()
            for key in [
                position + "right_margin",
                position + "top_margin",
                position + "left_margin",
                position + "bottom_margin",
            ]
            if (
                self.get_variable(key) is not None
                and self.get_variable(key).strip() != ""
            )
        }

        return margin_lines

    def validate_and_set_margins(self, margin_lines: dict[str, str]) -> dict[str, int]:
        """Set and validate the margin lines.

        Args:
            margin_lines (dict[str, str]): The dict consists of
                marginname:percentage pairs

        Returns:
            (dict[str, int]): The dict consists of marginname:percentage pairs.

        Raises:
            XsltException: Raise this exception if there are errors in the
                margin_lines.
        """
        _margins: dict[str, int] = {}
        for key, value in margin_lines.items():
            if (
                "all" in value
                and ("odd" in value or "even" in value)
                or "=" not in value
            ):
                raise XsltError(
                    "Invalid format in the variable {} in the file:\n{}\n{}\n"
                    "Format must be [all|odd|even|pagenumber]=integer".format(
                        key, self.filename, value
                    )
                )
            try:
                _margins[key] = self.parse_margin_line(value)
            except ValueError as error:
                raise XsltError(
                    "Invalid format in the variable {} in the file:\n{}\n{}\n"
                    "Format must be [all|odd|even|pagenumber]=integer".format(
                        key, self.filename, value
                    )
                ) from error

        return _margins

    @property
    def margins(self):
        """Parse margin lines fetched from the .xsl file.

        Returns:
            (dict): The dict consists of marginname:percentage pairs.
        """
        margin_lines = self.get_margin_lines()

        return self.validate_and_set_margins(margin_lines)

    @property
    def inner_margins(self):
        """Parse inner margin lines fetched from the .xsl file.

        Raises:
            XsltError: On errors in the inner_margin_lines.

        Returns:
            (dict): The dict consists of marginname:percentage pairs.
        """
        margin_lines = self.get_margin_lines(position="inner_")
        _inner_margins = self.validate_and_set_margins(margin_lines)

        keys = list(_inner_margins.keys())
        for key in keys:
            if key == "inner_left_margin":
                if "inner_right_margin" not in keys:
                    raise XsltError(
                        "Invalid format in {}:\nboth "
                        "inner_right_margin and inner_left_margin must "
                        "be set".format(self.filename)
                    )
                if sorted(_inner_margins["inner_left_margin"]) != sorted(
                    _inner_margins["inner_right_margin"]
                ):
                    raise XsltError(
                        "Invalid format in {}:\nboth "
                        "margins for the same pages must be set in "
                        "inner_right_margin and inner_left_margin".format(self.filename)
                    )
            if key == "inner_right_margin" and "inner_left_margin" not in keys:
                raise XsltError(
                    "Invalid format in {}:\nboth inner_right_margin "
                    "and inner_left_margin must be set".format(self.filename)
                )
            if key == "inner_bottom_margin":
                if "inner_top_margin" not in keys:
                    raise XsltError(
                        "Invalid format in {}:\nboth "
                        "inner_bottom_margin and inner_top_margin must "
                        "be set".format(self.filename)
                    )
                if sorted(_inner_margins["inner_bottom_margin"]) != sorted(
                    _inner_margins["inner_top_margin"]
                ):
                    raise XsltError(
                        "Invalid format in {}:\n"
                        "margins for the same pages must be set in "
                        "inner_top_margin and inner_bottom_margin".format(self.filename)
                    )
            if key == "inner_top_margin" and "inner_bottom_margin" not in keys:
                raise XsltError(
                    "Invalid format in {}:\nboth inner_bottom_margin "
                    "and inner_top_margin must be set".format(self.filename)
                )

        return _inner_margins

    @staticmethod
    def parse_margin_line(value: str) -> dict[str, int]:
        """Parse a margin line read from the .xsl file.

        Args:
            value: contains the margin settings for a particular
                margin (right_margin, left_margin, top_margin, bottom_margin)

        Returns:
            (dict[str, int]): a dictionary of margin name to percentages (as
                integers)
        """
        m: dict[str, int] = {}
        for part in value.split(","):
            (pages, margin) = tuple(part.split("="))
            for page in pages.split(";"):
                m[page.strip()] = int(margin)

        return m

    def set_lang_genre_xsl(self):
        """Set the mainlang and genre variables in the xsl file."""
        with util.ignored(TypeError):  # type: ignore
            path = corpuspath.make_corpus_path(self.filename)
            self.set_variable("mainlang", path.lang)
            self.set_variable("genre", path.filepath.parts[0])

    def write_file(self):
        """Write self.tree to self.filename."""
        try:
            with open(self.filename, "wb") as outfile:
                self.tree.write(outfile, encoding="utf-8", xml_declaration=True)
                outfile.write(b"\n")
        except OSError as e:
            print("cannot write", self.filename)
            print(e)
            sys.exit(254)

    @property
    def skip_elements(self) -> list[tuple[str, str]]:
        """Get the skip_elements variable.

        Returns:
            (list[tuple[xpath, xpath]]): each tuple has a (start, end) xpath
                path pair. If the skip_elements variable is empty, return None.
        """

        def get_with_ns(path: str) -> str:
            return "/".join(
                [
                    (
                        "html:" + part
                        if not part.startswith("html:") and re.match(r"^\w", part)
                        else part
                    )
                    for part in path.split("/")
                ]
            )

        def get_pair(pair: str) -> tuple[str, str]:
            p = pair.split(";")
            return (get_with_ns(p[0].strip()), get_with_ns(p[1].strip()))

        if self.get_variable("skip_elements"):
            return [
                get_pair(pair) for pair in self.get_variable("skip_elements").split(",")
            ]

        return []

    @property
    def linespacing(self) -> dict[str, float]:
        """:obj:`dict` of :obj:`str` pairs

        The key may be all, odd, even or a pagenumber, the value is a
        floating point number.

        Raises:
            XsltError: On invalid format
        """
        value = self.get_variable("linespacing")

        if value is None:
            return {}

        if (value) and (
            "all" in value and ("odd" in value or "even" in value) or "=" not in value
        ):
            raise XsltError(
                "Invalid format in the variable linespacing in the file:"
                "\n{}\n{}\n"
                "Format must be [all|odd|even|pagenumber]=float".format(
                    self.filename, value
                )
            )

        try:
            return self.parse_linespacing_line(value)
        except ValueError as error:
            raise XsltError(
                "Invalid format in the variable linespacing in the file:"
                "\n{}\n{}\n"
                "Format must be [all|odd|even|pagenumber]=float".format(
                    self.filename, value
                )
            ) from error

    @staticmethod
    def parse_linespacing_line(value: str) -> dict[str, float]:
        """Parse a linespacing line read from the .xsl file.

        Args:
            value: contains the linespacing

        Returns:
            page: linespacing pairs
        """
        line_dict: dict[str, float] = {}
        if value:
            for part in value.split(","):
                (pages, linespacing) = tuple(part.split("="))
                for page in pages.split(";"):
                    line_dict[page.strip()] = float(linespacing)

        return line_dict

    @property
    def xsl_templates(self):
        """Find all xsl:template elements.

        Returns:
            (list[xml.etree.Element]): List of etree.Element
        """
        ns = {"xsl": "http://www.w3.org/1999/XSL/Transform"}
        return self.tree.getroot().xpath(".//xsl:template", namespaces=ns)

epub_excluded_chapters property

Turn a skip_lines entry into a list of lines.

Returns:

Name	Type	Description
list	int	list of line to skip numbers as integers.

inner_margins property

Parse inner margin lines fetched from the .xsl file.

Raises:

Type	Description
XsltError	On errors in the inner_margin_lines.

Returns:

Type	Description
dict	The dict consists of marginname:percentage pairs.

linespacing property

:obj:dict of :obj:str pairs

The key may be all, odd, even or a pagenumber, the value is a floating point number.

Raises:

Type	Description
XsltError	On invalid format

margins property

Parse margin lines fetched from the .xsl file.

Returns:

Type	Description
dict	The dict consists of marginname:percentage pairs.

mlangs property

Get the languages to look for in the document.

Returns:

Type	Description
set[str]	A set of languages to look for in the document

skip_elements property

Get the skip_elements variable.

Returns:

Type	Description
list[tuple[xpath, xpath]]	each tuple has a (start, end) xpath path pair. If the skip_elements variable is empty, return None.

skip_lines property

Turn a skip_lines entry into a list of lines.

Returns:

Name	Type	Description
list	int	list of line to skip numbers as integers.

skip_pages property

Turn a skip_pages entry into a list of pages.

Returns:

Type	Description
list[int | str]	The list can contain the strings 'all', 'even' and 'odd' or specific page
list[int | str]	numbers as integers.

xsl_templates property

Find all xsl:template elements.

Returns:

Type	Description
list[Element]	List of etree.Element

__init__(filename, create=False)

Initialise the MetadataHandler class.

Parameters:

Name	Type	Description	Default
filename	Path	path to the metadata file.	required
create	bool	Define if a MetadataHandler will be created from a metadata file belonging to a original file inside the corpus or created from a template file containing default values. If false, try to read a metadata file, and create a MetadataHandler from this. If the file does not exist, raise a util.ArgumentError. If True, create a new MetadataHandler with default values from the template file.	False

Raises:

Type	Description
ArgumentError	if create is False and the filename does not exist.
XsltException	if there is a syntax error in the metadata file.

Source code in corpustools/xslsetter.py

def __init__(self, filename: Path, create: bool = False):
    """Initialise the MetadataHandler class.

    Args:
        filename: path to the metadata file.
        create (bool): Define if a MetadataHandler will be created from a
            metadata file belonging to a original file inside the corpus or
            created from a template file containing default values.

            If false, try to read a metadata file, and create a
            MetadataHandler from this. If the file does not exist, raise a
            util.ArgumentError.

            If True, create a new MetadataHandler with default values
            from the template file.

    Raises:
        util.ArgumentError:if create is False and the filename does not
            exist.
        XsltException: if there is a syntax error in the metadata file.
    """
    self.filename = filename

    if not filename.exists():
        if not create:
            raise util.ArgumentError(f"{filename} does not exist!")
        self.tree = etree.parse(here / "xslt/XSL-template.xsl")
    else:
        try:
            self.tree = etree.parse(filename)
        except etree.XMLSyntaxError as error:
            raise XsltError(f"Syntax error in {self.filename}:\n{error}") from error

get_margin_lines(position='')

Get the margin lines from the metadata file.

Parameters:

Name	Type	Description	Default
position	str	empty if getting regular margin lines, otherwise inner_ if getting inner margin lines.	''

Returns:

Type	Description
dict[str, str]	A dictionary of margin name to percentages

Source code in corpustools/xslsetter.py

def get_margin_lines(self, position: str = "") -> dict[str, str]:
    """Get the margin lines from the metadata file.

    Args:
        position: empty if getting regular margin lines,
            otherwise inner_ if getting inner margin lines.

    Returns:
        A dictionary of margin name to percentages
    """
    margin_lines = {
        key: self.get_variable(key).strip()
        for key in [
            position + "right_margin",
            position + "top_margin",
            position + "left_margin",
            position + "bottom_margin",
        ]
        if (
            self.get_variable(key) is not None
            and self.get_variable(key).strip() != ""
        )
    }

    return margin_lines

get_parallel_texts()

Get the parallel texts.

Returns:

Type	Description
dict[str, str]	A dict of parallel files containing language:filename pairs.

Source code in corpustools/xslsetter.py

def get_parallel_texts(self) -> dict[str, str]:
    """Get the parallel texts.

    Returns:
        A dict of parallel files containing language:filename pairs.
    """
    parallels = self._get_variable_elt("parallels")
    if parallels is None:
        return {}
    else:
        elts = parallels.findall("parallel_text")
        return {
            p.attrib[self.lang_key]: p.attrib["location"].strip("'")
            for p in elts
            if p.attrib["location"].strip("'") != ""
        }

get_set_variables()

Find all set variables.

Yields:

Type	Description
tuple[str, Any]	a key/value pair

Source code in corpustools/xslsetter.py

def get_set_variables(self):
    """Find all set variables.

    Yields:
        (tuple[str, Any]): a key/value pair
    """
    ns = {"xsl": "http://www.w3.org/1999/XSL/Transform"}
    for variable in self.tree.getroot().xpath(
        ".//xsl:variable[@select]", namespaces=ns
    ):
        value = self.get_variable(variable.get("name"))
        if value is not None and value.strip():
            yield variable.get("name"), value

get_variable(key)

Get the value associated with the key.

Parameters:

Name	Type	Description	Default
key	str	Name of the variable to get.	required

Returns:

Type	Description
str | None	The string contains the value associated with the key.

Source code in corpustools/xslsetter.py

def get_variable(self, key: str) -> str | None:
    """Get the value associated with the key.

    Args:
        key: Name of the variable to get.

    Returns:
        (str|None): The string contains the value associated with the key.
    """
    variable = self._get_variable_elt(key)
    if variable is not None:
        value = variable.attrib["select"]
        clean_value = value.replace("'", "")
        if clean_value:
            return clean_value

    return None

parse_linespacing_line(value) staticmethod

Parse a linespacing line read from the .xsl file.

Parameters:

Name	Type	Description	Default
value	str	contains the linespacing	required

Returns:

Name	Type	Description
page	dict[str, float]	linespacing pairs

Source code in corpustools/xslsetter.py

@staticmethod
def parse_linespacing_line(value: str) -> dict[str, float]:
    """Parse a linespacing line read from the .xsl file.

    Args:
        value: contains the linespacing

    Returns:
        page: linespacing pairs
    """
    line_dict: dict[str, float] = {}
    if value:
        for part in value.split(","):
            (pages, linespacing) = tuple(part.split("="))
            for page in pages.split(";"):
                line_dict[page.strip()] = float(linespacing)

    return line_dict

parse_margin_line(value) staticmethod

Parse a margin line read from the .xsl file.

Parameters:

Name	Type	Description	Default
value	str	contains the margin settings for a particular margin (right_margin, left_margin, top_margin, bottom_margin)	required

Returns:

Type	Description
dict[str, int]	a dictionary of margin name to percentages (as integers)

Source code in corpustools/xslsetter.py

@staticmethod
def parse_margin_line(value: str) -> dict[str, int]:
    """Parse a margin line read from the .xsl file.

    Args:
        value: contains the margin settings for a particular
            margin (right_margin, left_margin, top_margin, bottom_margin)

    Returns:
        (dict[str, int]): a dictionary of margin name to percentages (as
            integers)
    """
    m: dict[str, int] = {}
    for part in value.split(","):
        (pages, margin) = tuple(part.split("="))
        for page in pages.split(";"):
            m[page.strip()] = int(margin)

    return m

set_lang_genre_xsl()

Set the mainlang and genre variables in the xsl file.

Source code in corpustools/xslsetter.py

def set_lang_genre_xsl(self):
    """Set the mainlang and genre variables in the xsl file."""
    with util.ignored(TypeError):  # type: ignore
        path = corpuspath.make_corpus_path(self.filename)
        self.set_variable("mainlang", path.lang)
        self.set_variable("genre", path.filepath.parts[0])

set_mlang(language)

Set a language in mlangs.

Parameters:

Name	Type	Description	Default
language	str	a language code that should be set.	required

Source code in corpustools/xslsetter.py

def set_mlang(self, language: str):
    """Set a language in mlangs.

    Args:
        language: a language code that should be set.
    """
    mlangs = self._get_variable_elt("mlangs")
    if mlangs is None:
        mlangs = self.make_xsl_variable("mlangs")

    if language not in self.mlangs:
        mlang = etree.Element("language")
        mlang.attrib.update({self.lang_key: language})
        mlangs.append(mlang)

set_parallel_text(language, location)

Insert the name of a parallel file into the parallels element.

Parameters:

Name	Type	Description	Default
language	str	the language of the parallel file.	required
location	str	the name of the parallel file.	required

Source code in corpustools/xslsetter.py

def set_parallel_text(self, language: str, location: str):
    """Insert the name of a parallel file into the parallels element.

    Args:
        language: the language of the parallel file.
        location: the name of the parallel file.
    """
    attrib = {self.lang_key: language, "location": location}
    parallels = self._get_variable_elt("parallels")
    if parallels is None:
        parallels = self.make_xsl_variable("parallels")

    elt = parallels.find(f"parallel_text[@{self.lang_key}='{language}']")
    if elt is not None:
        elt.attrib.update(attrib)
    else:
        elt = etree.Element("parallel_text", attrib=attrib)
        elt.tail = "\n"
        parallels.append(elt)

set_variable(key, value)

Set the value of a variable.

Parameters:

Name	Type	Description	Default
key	str	Name of the variable to set.	required
value	str	The value the variable should be set to.	required

Source code in corpustools/xslsetter.py

def set_variable(self, key: str, value: str):
    """Set the value of a variable.

    Args:
        key: Name of the variable to set.
        value: The value the variable should be set to.
    """
    try:
        variable = self._get_variable_elt(key)
        if variable is None:
            variable = self.make_xsl_variable(key)
        variable.attrib["select"] = f"'{value}'"
    except AttributeError as error:
        raise UserWarning(
            "Tried to update {} with value {}\nError was {}".format(
                key, value, str(error)
            )
        ) from error

validate_and_set_margins(margin_lines)

Set and validate the margin lines.

Parameters:

Name	Type	Description	Default
margin_lines	dict[str, str]	The dict consists of marginname:percentage pairs	required

Returns:

Type	Description
dict[str, int]	The dict consists of marginname:percentage pairs.

Raises:

Type	Description
XsltException	Raise this exception if there are errors in the margin_lines.

Source code in corpustools/xslsetter.py

def validate_and_set_margins(self, margin_lines: dict[str, str]) -> dict[str, int]:
    """Set and validate the margin lines.

    Args:
        margin_lines (dict[str, str]): The dict consists of
            marginname:percentage pairs

    Returns:
        (dict[str, int]): The dict consists of marginname:percentage pairs.

    Raises:
        XsltException: Raise this exception if there are errors in the
            margin_lines.
    """
    _margins: dict[str, int] = {}
    for key, value in margin_lines.items():
        if (
            "all" in value
            and ("odd" in value or "even" in value)
            or "=" not in value
        ):
            raise XsltError(
                "Invalid format in the variable {} in the file:\n{}\n{}\n"
                "Format must be [all|odd|even|pagenumber]=integer".format(
                    key, self.filename, value
                )
            )
        try:
            _margins[key] = self.parse_margin_line(value)
        except ValueError as error:
            raise XsltError(
                "Invalid format in the variable {} in the file:\n{}\n{}\n"
                "Format must be [all|odd|even|pagenumber]=integer".format(
                    key, self.filename, value
                )
            ) from error

    return _margins

write_file()

Write self.tree to self.filename.

Source code in corpustools/xslsetter.py

def write_file(self):
    """Write self.tree to self.filename."""
    try:
        with open(self.filename, "wb") as outfile:
            self.tree.write(outfile, encoding="utf-8", xml_declaration=True)
            outfile.write(b"\n")
    except OSError as e:
        print("cannot write", self.filename)
        print(e)
        sys.exit(254)

XsltError

Bases: Exception

Raise this exception when errors arise in this module.

Source code in corpustools/xslsetter.py

class XsltError(Exception):
    """Raise this exception when errors arise in this module."""