Add files using upload-large-folder tool

evalkit_tf437/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_size.py

@@ -0,0 +1,248 @@
+"""
+Provides classes of simple units that will be used with `.AxesDivider`
+class (or others) to determine the size of each Axes. The unit
+classes define `get_size` method that returns a tuple of two floats,
+meaning relative and absolute sizes, respectively.
+
+Note that this class is nothing more than a simple tuple of two
+floats. Take a look at the Divider class to see how these two
+values are used.
+"""
+
+from numbers import Real
+
+from matplotlib import _api
+from matplotlib.axes import Axes
+
+
+class _Base:
+    def __rmul__(self, other):
+        return Fraction(other, self)
+
+    def __add__(self, other):
+        if isinstance(other, _Base):
+            return Add(self, other)
+        else:
+            return Add(self, Fixed(other))
+
+    def get_size(self, renderer):
+        """
+        Return two-float tuple with relative and absolute sizes.
+        """
+        raise NotImplementedError("Subclasses must implement")
+
+
+class Add(_Base):
+    """
+    Sum of two sizes.
+    """
+
+    def __init__(self, a, b):
+        self._a = a
+        self._b = b
+
+    def get_size(self, renderer):
+        a_rel_size, a_abs_size = self._a.get_size(renderer)
+        b_rel_size, b_abs_size = self._b.get_size(renderer)
+        return a_rel_size + b_rel_size, a_abs_size + b_abs_size
+
+
+class Fixed(_Base):
+    """
+    Simple fixed size with absolute part = *fixed_size* and relative part = 0.
+    """
+
+    def __init__(self, fixed_size):
+        _api.check_isinstance(Real, fixed_size=fixed_size)
+        self.fixed_size = fixed_size
+
+    def get_size(self, renderer):
+        rel_size = 0.
+        abs_size = self.fixed_size
+        return rel_size, abs_size
+
+
+class Scaled(_Base):
+    """
+    Simple scaled(?) size with absolute part = 0 and
+    relative part = *scalable_size*.
+    """
+
+    def __init__(self, scalable_size):
+        self._scalable_size = scalable_size
+
+    def get_size(self, renderer):
+        rel_size = self._scalable_size
+        abs_size = 0.
+        return rel_size, abs_size
+
+Scalable = Scaled
+
+
+def _get_axes_aspect(ax):
+    aspect = ax.get_aspect()
+    if aspect == "auto":
+        aspect = 1.
+    return aspect
+
+
+class AxesX(_Base):
+    """
+    Scaled size whose relative part corresponds to the data width
+    of the *axes* multiplied by the *aspect*.
+    """
+
+    def __init__(self, axes, aspect=1., ref_ax=None):
+        self._axes = axes
+        self._aspect = aspect
+        if aspect == "axes" and ref_ax is None:
+            raise ValueError("ref_ax must be set when aspect='axes'")
+        self._ref_ax = ref_ax
+
+    def get_size(self, renderer):
+        l1, l2 = self._axes.get_xlim()
+        if self._aspect == "axes":
+            ref_aspect = _get_axes_aspect(self._ref_ax)
+            aspect = ref_aspect / _get_axes_aspect(self._axes)
+        else:
+            aspect = self._aspect
+
+        rel_size = abs(l2-l1)*aspect
+        abs_size = 0.
+        return rel_size, abs_size
+
+
+class AxesY(_Base):
+    """
+    Scaled size whose relative part corresponds to the data height
+    of the *axes* multiplied by the *aspect*.
+    """
+
+    def __init__(self, axes, aspect=1., ref_ax=None):
+        self._axes = axes
+        self._aspect = aspect
+        if aspect == "axes" and ref_ax is None:
+            raise ValueError("ref_ax must be set when aspect='axes'")
+        self._ref_ax = ref_ax
+
+    def get_size(self, renderer):
+        l1, l2 = self._axes.get_ylim()
+
+        if self._aspect == "axes":
+            ref_aspect = _get_axes_aspect(self._ref_ax)
+            aspect = _get_axes_aspect(self._axes)
+        else:
+            aspect = self._aspect
+
+        rel_size = abs(l2-l1)*aspect
+        abs_size = 0.
+        return rel_size, abs_size
+
+
+class MaxExtent(_Base):
+    """
+    Size whose absolute part is either the largest width or the largest height
+    of the given *artist_list*.
+    """
+
+    def __init__(self, artist_list, w_or_h):
+        self._artist_list = artist_list
+        _api.check_in_list(["width", "height"], w_or_h=w_or_h)
+        self._w_or_h = w_or_h
+
+    def add_artist(self, a):
+        self._artist_list.append(a)
+
+    def get_size(self, renderer):
+        rel_size = 0.
+        extent_list = [
+            getattr(a.get_window_extent(renderer), self._w_or_h) / a.figure.dpi
+            for a in self._artist_list]
+        abs_size = max(extent_list, default=0)
+        return rel_size, abs_size
+
+
+class MaxWidth(MaxExtent):
+    """
+    Size whose absolute part is the largest width of the given *artist_list*.
+    """
+
+    def __init__(self, artist_list):
+        super().__init__(artist_list, "width")
+
+
+class MaxHeight(MaxExtent):
+    """
+    Size whose absolute part is the largest height of the given *artist_list*.
+    """
+
+    def __init__(self, artist_list):
+        super().__init__(artist_list, "height")
+
+
+class Fraction(_Base):
+    """
+    An instance whose size is a *fraction* of the *ref_size*.
+
+    >>> s = Fraction(0.3, AxesX(ax))
+    """
+
+    def __init__(self, fraction, ref_size):
+        _api.check_isinstance(Real, fraction=fraction)
+        self._fraction_ref = ref_size
+        self._fraction = fraction
+
+    def get_size(self, renderer):
+        if self._fraction_ref is None:
+            return self._fraction, 0.
+        else:
+            r, a = self._fraction_ref.get_size(renderer)
+            rel_size = r*self._fraction
+            abs_size = a*self._fraction
+            return rel_size, abs_size
+
+
+def from_any(size, fraction_ref=None):
+    """
+    Create a Fixed unit when the first argument is a float, or a
+    Fraction unit if that is a string that ends with %. The second
+    argument is only meaningful when Fraction unit is created.
+
+    >>> from mpl_toolkits.axes_grid1.axes_size import from_any
+    >>> a = from_any(1.2) # => Fixed(1.2)
+    >>> from_any("50%", a) # => Fraction(0.5, a)
+    """
+    if isinstance(size, Real):
+        return Fixed(size)
+    elif isinstance(size, str):
+        if size[-1] == "%":
+            return Fraction(float(size[:-1]) / 100, fraction_ref)
+    raise ValueError("Unknown format")
+
+
+class _AxesDecorationsSize(_Base):
+    """
+    Fixed size, corresponding to the size of decorations on a given Axes side.
+    """
+
+    _get_size_map = {
+        "left":   lambda tight_bb, axes_bb: axes_bb.xmin - tight_bb.xmin,
+        "right":  lambda tight_bb, axes_bb: tight_bb.xmax - axes_bb.xmax,
+        "bottom": lambda tight_bb, axes_bb: axes_bb.ymin - tight_bb.ymin,
+        "top":    lambda tight_bb, axes_bb: tight_bb.ymax - axes_bb.ymax,
+    }
+
+    def __init__(self, ax, direction):
+        _api.check_in_list(self._get_size_map, direction=direction)
+        self._direction = direction
+        self._ax_list = [ax] if isinstance(ax, Axes) else ax
+
+    def get_size(self, renderer):
+        sz = max([
+            self._get_size_map[self._direction](
+                ax.get_tightbbox(renderer, call_axes_locator=False), ax.bbox)
+            for ax in self._ax_list])
+        dpi = renderer.points_to_pixels(72)
+        abs_size = sz / dpi
+        rel_size = 0
+        return rel_size, abs_size

falcon/lib/python3.10/site-packages/RUST/amino.py

@@ -0,0 +1,420 @@
+#!/usr/bin/python
+#####################################################################################
+# rust_amino, Produces RUST metagene profile of amino acids
+# Copyright (C) 2015 Patrick O'Connor
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#####################################################################################
+
+import os, re, pysam, sys, math, argparse
+from .methods import *
+
+try:
+    import matplotlib as mpl
+
+    mpl.use("Agg")
+    import matplotlib.pyplot as plt
+    from pylab import log2, MaxNLocator
+except:
+    pass
+
+
+def RUST_metagene_plot(infileopen36, ax36):
+    infileopen36.seek(0)
+    infileopen36.readline()
+    while 1:
+        line = infileopen36.readline()
+        linesplit = line.split(",")
+        if len(linesplit) == 1:
+            break
+        codon = linesplit[0]
+        coverage = list(map(float, linesplit[1:]))
+        coverage_a = coverage[0]
+        if coverage_a == 0:
+            continue
+        coverage_n = [n / coverage_a for n in coverage[1:]]
+        log2_values = [math.log(n, 2) for n in coverage_n]
+        ax36.plot(log2_values, color="gray")
+        # print log2(coverage_n) == math.log(coverage_n,2)
+
+    line = infileopen36.readline()
+    linesplit = line.split(",")
+    if "NA" not in line:
+        coverage = list(map(float, linesplit[2:]))
+        ax2 = ax36.twinx()
+        ax2.plot(coverage, color="blue")
+        for tl in ax2.get_yticklabels():
+            tl.set_color("blue")
+            tl.set_rotation(0)
+
+        ax2.yaxis.set_major_locator(MaxNLocator(3))
+        ax2.set_ylim(0, 1.0)
+        ax2.set_ylim(-2, 1.0)
+        ax2.set_yticks([0, 1], minor=False)
+        ax2.set_yticklabels(["0", "1"])
+        ax2.set_ylabel("Kullback-Leibler divergence", color="blue")
+
+    ax36.set_xticks([5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55])
+    ax36.set_xticklabels([-35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15])
+    ax36.set_xlabel("distance from A-site [codon]")
+    ax36.set_ylabel("Amino acid RUST ratio (observed/expected), log2")
+    ax36.axvline(40, color="red")
+
+
+def main(args):
+
+    mRNA_sequences = args.transcriptome  # path to fastq file of transcripts
+    in_seq_handle = open(mRNA_sequences)
+    cds_start_dict = {}
+    cds_end_dict = {}
+    seq_dict = {}
+    for line in in_seq_handle:
+        if line[0] != ">":
+            seq_dict.setdefault(transcript, "")
+            seq_dict[transcript] += line[:-1]
+            continue
+        try:
+            transcript_split = line[:-1].split("\t")
+            transcript = transcript_split[0][1:]
+            cds_start_dict[transcript] = int(transcript_split[1])
+            cds_end_dict[transcript] = int(transcript_split[2])
+        except:
+            pass
+    in_seq_handle.close()
+
+    offset = args.offset
+    readlen_range = args.lengths
+    readlen_rangesplit = readlen_range.split(":")
+    if len(readlen_rangesplit) == 1:
+        accepted_read_lengths = [int(readlen_rangesplit[0])]
+        length_values = "%s" % int(readlen_rangesplit[0])
+    elif len(readlen_rangesplit) == 2:
+        accepted_read_lengths = [
+            readlen
+            for readlen in range(
+                int(readlen_rangesplit[0]), int(readlen_rangesplit[1]) + 1
+            )
+        ]
+        length_values = "%s_%s" % (
+            int(readlen_rangesplit[0]),
+            int(readlen_rangesplit[1]),
+        )
+    else:
+        stop_err(
+            "Lengths of footprints parameter not in correct format, it should be either colon seperated with the second value greater or equal to the first, (28:32) or a single interger (31)"
+        )
+    if len(accepted_read_lengths) == 0:
+        stop_err(
+            "Lengths of footprints parameter not in correct format, it should be either colon seperated with the second value greater or equal to the first, (28:32) or a single interger (31)"
+        )
+
+    amino_acids = [
+        "A",
+        "C",
+        "E",
+        "D",
+        "G",
+        "F",
+        "I",
+        "H",
+        "K",
+        "M",
+        "L",
+        "N",
+        "Q",
+        "P",
+        "S",
+        "R",
+        "T",
+        "W",
+        "V",
+        "Y",
+    ]
+    aligments_A1 = pysam.Samfile(
+        args.alignment, "rb"
+    )  # path to aligments in bam format
+
+    amino_enrichment_dict = {}
+    codon_enrichment_expected_dict = {}
+    for amino_acid in amino_acids:
+        amino_enrichment_dict[amino_acid] = {}
+        codon_enrichment_expected_dict[amino_acid] = []
+        for number in range(0, 60, 1):
+            amino_enrichment_dict[amino_acid][number] = [0.0, 0.0]
+
+    list_transcripts = seq_dict.keys()
+    number_transcripts = 0
+    list_10_percentile = []
+    for value in range(1, 10):
+        list_10_percentile.append((len(list_transcripts) * value) / 10)
+    for transcript in list_transcripts:
+        number_transcripts += 1
+        if number_transcripts in list_10_percentile:
+            sys.stdout.write(
+                "%s percent\n"
+                % ((list_10_percentile.index(number_transcripts) + 1) * 10)
+            )
+        try:  # use supplied CDS annotation
+            cds_start = cds_start_dict[transcript]
+            cds_end = cds_end_dict[transcript]
+            if cds_end < cds_start:
+                raise Exception
+        except Exception:  # find longest ORF
+            transcript_seq = seq_dict[transcript]
+            cds_start = -1
+            start_post = []
+            end_post = []
+            for match in re.finditer(r"(?=(%s))" % re.escape("ATG"), transcript_seq):
+                start_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TAG"), transcript_seq):
+                end_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TAA"), transcript_seq):
+                end_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TGA"), transcript_seq):
+                end_post.append(match.start())
+
+            end_post.sort()
+            len_max_orf = 0
+            for value in start_post:
+                for value2 in end_post:
+                    if value < value2:
+                        if value % 3 == value2 % 3:
+                            len_orf = value2 - value
+                            if len_orf > len_max_orf:
+                                cds_start = value
+                                cds_end = value2 + 3
+                                len_max_orf = len_orf
+                            break
+            if cds_start == -1:
+                # sys.stdout.write( '%s, AUG codon not found\n'%transcript  )
+                continue
+
+        elongation_region_all = seq_dict[transcript][cds_start:cds_end]
+        elongation_region_part = elongation_region_all[
+            120:-60
+        ]  # first 120 and last 60 nt are not used
+
+        if len(elongation_region_part) % 3 != 0:
+            # sys.stdout.write( '%s, CDS not divisible by 3\n'%transcript  )
+            continue
+        peptide_sequence = translate_dna(elongation_region_all)
+        profile_list = [
+            0.0 for n in range(cds_start + 120, cds_end - 60)
+        ]  # records ribo-seq profile
+        if len(profile_list) < 50:
+            # sys.stdout.write( '%s, ORF too short\n'%transcript  )
+            continue
+        all_reads = aligments_A1.fetch(transcript)
+
+        len_elongation_region = len(profile_list)
+        for read in all_reads:
+            readlen = read.qlen
+            if readlen not in accepted_read_lengths:
+                continue  # selection of read of acceptable length
+            A_site = read.pos + offset - cds_start - 120  # addition of offset
+            if len_elongation_region > A_site > -1:
+                profile_list[A_site] += 1
+
+        average_gene_density = float(sum(profile_list)) / len(
+            profile_list
+        )  # average gene density calculated
+
+        if average_gene_density != 0:
+            num_codon = len(
+                [
+                    1
+                    for number88 in range(0, len(profile_list), 3)
+                    if (
+                        (
+                            profile_list[number88]
+                            + profile_list[number88 + 1]
+                            + profile_list[number88 + 2]
+                        )
+                        / 3
+                    )
+                    > average_gene_density
+                ]
+            )
+            # number of codons that exceed average gene density
+            expected_codon_density = float(num_codon) / (
+                len(profile_list) / 3
+            )  # expected enrichment value
+
+            peptide_start = 0
+            for sliding_w_n in range(
+                0, len(elongation_region_part), 3
+            ):  # sliding window using increments of 3 nts
+                amino_window = str(peptide_sequence[peptide_start : peptide_start + 60])
+                if len(set(amino_window) - set(amino_acids)) != 0:
+                    peptide_start += 1
+                    continue
+
+                if (
+                    profile_list[sliding_w_n]
+                    + profile_list[sliding_w_n + 1]
+                    + profile_list[sliding_w_n + 2]
+                ) / 3 > average_gene_density:
+                    for number in range(0, 60):
+                        amino_acid_1 = amino_window[number : number + 1]
+                        amino_enrichment_dict[amino_acid_1][number][0] += 1
+                        amino_enrichment_dict[amino_acid_1][number][1] += 1
+                else:
+                    for number in range(0, 60):
+                        amino_acid_1 = amino_window[number : number + 1]
+                        amino_enrichment_dict[amino_acid_1][number][0] += 1
+
+                amino_acid_1 = amino_window[40:41]
+                codon_enrichment_expected_dict[amino_acid_1].append(
+                    expected_codon_density
+                )
+
+                peptide_start += 1
+
+    alignment_filename = args.alignment.split("/")[-1]
+    if not os.path.exists(args.Path):
+        os.mkdir(args.o)
+    outfile = open(
+        "%s/RUST_amino_file_%s_%s_%s"
+        % (args.Path, alignment_filename, args.offset, length_values),
+        "w",
+    )
+    outfile.write("amino, expected value")
+    for number106 in range(-40, 20):
+        outfile.write(", %s" % number106)
+    outfile.write("\n")
+
+    list_codons = []
+    list_amino_acids = list(amino_enrichment_dict)
+    list_amino_acids.sort()
+    rust_expected = []
+    rust_observed_metafootprint = []
+    for amino2 in list_amino_acids:
+        if amino2 in list_codons:
+            continue
+        list_codons.append(amino2)
+        outfile.write("%s" % amino2)
+        if codon_enrichment_expected_dict[amino2] != []:
+            outfile.write(", %s" % mean_value(codon_enrichment_expected_dict[amino2]))
+        list_data = []
+        for number in range(0, 60):
+            if amino_enrichment_dict[amino2][number][0] != 0:
+                outfile.write(
+                    ", %s"
+                    % (
+                        amino_enrichment_dict[amino2][number][1]
+                        / amino_enrichment_dict[amino2][number][0]
+                    )
+                )
+                list_data.append(
+                    amino_enrichment_dict[amino2][number][1]
+                    / amino_enrichment_dict[amino2][number][0]
+                )
+            else:
+                outfile.write(", 0")
+                list_data.append(0)
+        outfile.write("\n")
+        rust_expected.append(mean_value(codon_enrichment_expected_dict[amino2]))
+        rust_observed_metafootprint.append(list_data)
+
+    rust_expected_sum = sum(rust_expected)
+    q_values = [n / rust_expected_sum for n in rust_expected]
+    shannon_values = []
+    for loc_i in range(60):
+        rust_observed = [n[loc_i] for n in rust_observed_metafootprint]
+        rust_observed_sum = sum(rust_observed)
+        rust_observed_min = min(rust_observed)
+        if rust_observed_min == 0:
+            shannon_values.append("NA")
+        else:
+            p_values = [n / rust_observed_sum for n in rust_observed]
+            shannon = []
+            list_normalised = []  ####
+            for p_value, q_value in zip(p_values, q_values):
+                shannon.append(abs(p_value * math.log((p_value / q_value), 2)))
+                list_normalised.append(p_value / q_value)  ####
+            shannon_values.append(sum(shannon))
+
+    outfile.write("\nKullback Leibler divergence ,")
+    for value in shannon_values:
+        outfile.write(", %s" % value)
+    outfile.close()
+
+    try:
+        mpl.rcParams["xtick.direction"] = "out"
+        mpl.rcParams["ytick.direction"] = "out"
+        mpl.rcParams["legend.fontsize"] = 10
+        mpl.rcParams["ytick.labelsize"] = 10
+        mpl.rcParams["xtick.labelsize"] = 10
+        mpl.rcParams["font.size"] = 10
+        mpl.rcParams["axes.titlesize"] = 10
+        mpl.rcParams["legend.frameon"] = 0
+        mpl.rcParams["axes.axisbelow"] = False
+        mpl.rcParams["xtick.major.pad"] = 2.0
+        mpl.rcParams["ytick.major.pad"] = 2
+        mpl.rcParams["xtick.major.size"] = 2.0
+        mpl.rcParams["ytick.major.size"] = 2
+        mpl.rcParams["axes.linewidth"] = 0.5
+        mpl.rcParams["ytick.major.width"] = 0.25
+        mpl.rcParams["xtick.major.width"] = 0.25
+        mpl.rcParams["lines.linewidth"] = 1
+        mpl.rcParams["legend.borderpad"] = 0.01
+        mpl.rcParams["legend.labelspacing"] = 0.05
+        mpl.rcParams["legend.columnspacing"] = 0.5
+        mpl.rcParams["legend.borderaxespad"] = 0.15
+        mpl.rcParams["legend.handlelength"] = 1
+
+        fig = plt.figure(figsize=(6.69, 6.0))
+        infileopen = open(
+            "%s/RUST_amino_file_%s_%s_%s"
+            % (args.Path, alignment_filename, args.offset, length_values)
+        )
+        ax1_metafootprint = fig.add_subplot(111)
+        RUST_metagene_plot(infileopen, ax1_metafootprint)
+        plt.savefig(
+            "%s/RUST_amino_metafootprint_%s_%s_%s.png"
+            % (args.Path, alignment_filename, args.offset, length_values)
+        )
+    except:
+        sys.stdout.write("Error producing images\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Produces RUST metagene profile of amino acids"
+    )
+    parser.add_argument("--version", action="version", version="%(prog)s 1.2")
+
+    parser.add_argument(
+        "-t",
+        "--transcriptome",
+        help="fasta file of transcripts, CDS start and end may be provided on description line using tab separation e.g. >NM_0001  10  5000, otherwise it searches for longest ORF"
+        ", required=True",
+    )
+    parser.add_argument(
+        "-a",
+        "--alignment",
+        help="sorted bam file of transcriptome alignments",
+        required=True,
+    )
+    parser.add_argument("-o", "--offset", help="nucleotide offset to A-site", type=int)
+    parser.add_argument(
+        "-l",
+        "--lengths",
+        help="lengths of footprints included, for example 28:32 is 28,29,30,31,32",
+    )
+    parser.add_argument(
+        "-P", "--Path", help='path to outputfile, default is "amino"', default="amino"
+    )
+    args = parser.parse_args(None)
+    main(args)

falcon/lib/python3.10/site-packages/RUST/methods.py

@@ -0,0 +1,94 @@
+"""
+This module contains methods for the RUST tool 
+These are general purpose functions that are used in the RUST tool
+
+"""
+import sys
+
+
+def stop_err(msg):
+    sys.stderr.write("%s\n" % msg)
+    sys.exit()
+
+
+def mean_value(input_list):
+    if len(input_list) == 0:
+        return 0
+    else:
+        return sum(map(float, input_list)) / len(input_list)
+
+
+def translate_dna(sequence):
+    codontable = {
+        "ATA": "I",
+        "ATC": "I",
+        "ATT": "I",
+        "ATG": "M",
+        "ACA": "T",
+        "ACC": "T",
+        "ACG": "T",
+        "ACT": "T",
+        "AAC": "N",
+        "AAT": "N",
+        "AAA": "K",
+        "AAG": "K",
+        "AGC": "S",
+        "AGT": "S",
+        "AGA": "R",
+        "AGG": "R",
+        "CTA": "L",
+        "CTC": "L",
+        "CTG": "L",
+        "CTT": "L",
+        "CCA": "P",
+        "CCC": "P",
+        "CCG": "P",
+        "CCT": "P",
+        "CAC": "H",
+        "CAT": "H",
+        "CAA": "Q",
+        "CAG": "Q",
+        "CGA": "R",
+        "CGC": "R",
+        "CGG": "R",
+        "CGT": "R",
+        "GTA": "V",
+        "GTC": "V",
+        "GTG": "V",
+        "GTT": "V",
+        "GCA": "A",
+        "GCC": "A",
+        "GCG": "A",
+        "GCT": "A",
+        "GAC": "D",
+        "GAT": "D",
+        "GAA": "E",
+        "GAG": "E",
+        "GGA": "G",
+        "GGC": "G",
+        "GGG": "G",
+        "GGT": "G",
+        "TCA": "S",
+        "TCC": "S",
+        "TCG": "S",
+        "TCT": "S",
+        "TTC": "F",
+        "TTT": "F",
+        "TTA": "L",
+        "TTG": "L",
+        "TAC": "Y",
+        "TAT": "Y",
+        "TAA": "*",
+        "TAG": "*",
+        "TGC": "C",
+        "TGT": "C",
+        "TGA": "*",
+        "TGG": "W",
+    }
+    proteinsequence = ""
+    for n in range(0, len(sequence), 3):
+        try:
+            proteinsequence += codontable[sequence[n : n + 3]]
+        except:
+            proteinsequence += "X"
+    return proteinsequence

falcon/lib/python3.10/site-packages/RUST/nucleotide.py

@@ -0,0 +1,416 @@
+#!/usr/bin/python
+#####################################################################################
+# rust_nucleotide, Produces RUST metagene profile of nucleotides
+# Copyright (C) 2015 Patrick O'Connor
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#####################################################################################
+
+import os, re, pysam, sys, math, argparse
+from RUST.methods import *
+
+try:
+    import matplotlib as mpl
+
+    mpl.use("Agg")
+    import matplotlib.pyplot as plt
+    from pylab import MaxNLocator
+except:
+    pass
+
+
+def RUST_metagene_plot(infileopen36, ax36):
+    infileopen36.seek(0)
+    infileopen36.readline()
+    while 1:
+        line = infileopen36.readline()
+        linesplit = line.split(",")
+        if len(linesplit) == 1:
+            break
+        nucleotide_type = linesplit[0]
+        coverage = list(map(float, linesplit[1:]))
+        coverage_a = coverage[0]
+        if coverage_a == 0:
+            continue
+        coverage_n = [n / coverage_a for n in coverage[1:]]
+        # ax36.plot(log2(coverage_n[:-2]),color = "gray")
+        log2_values = [math.log(n, 2) for n in coverage_n]
+        if nucleotide_type == "A":
+            ax36.plot(log2_values, color="firebrick", label=nucleotide_type)
+        elif nucleotide_type == "T":
+            ax36.plot(log2_values, color="seagreen", label=nucleotide_type)
+        elif nucleotide_type == "G":
+            ax36.plot(log2_values, color="Orange", label=nucleotide_type)
+        else:
+            ax36.plot(log2_values, color="MediumPurple", label=nucleotide_type)
+
+    line = infileopen36.readline()
+    linesplit = line.split(",")
+    if "NA" not in linesplit:
+        coverage = list(map(float, linesplit[2:]))
+        ax2 = ax36.twinx()
+        ax2.plot(coverage, color="blue")
+        for tl in ax2.get_yticklabels():
+            tl.set_color("blue")
+            tl.set_rotation(0)
+
+        ax2.yaxis.set_major_locator(MaxNLocator(3))
+        ax2.set_ylim(0, 1.0)
+        ax2.set_ylim(-2, 1.0)
+        ax2.set_yticks([0, 1], minor=False)
+        ax2.set_yticklabels(["0", "1"])
+        ax2.set_ylabel("Kullback-Leibler divergence", color="blue")
+
+    ax36.set_xticks([15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165])
+    ax36.set_xticklabels([-105, -90, -75, -60, -45, -30, -15, 0, 15, 30, 45])
+    ax36.set_xlabel("distance from A-site [codon]")
+    ax36.set_ylabel("Nucleotide RUST ratio (observed/expected), log2")
+    ax36.axvline(120, color="red")
+    ax36.legend(bbox_to_anchor=(0, 0, 0.2, 0.9))
+
+
+def main(args):
+
+    mRNA_sequences = args.transcriptome  # path to fastq file of transcripts
+    in_seq_handle = open(mRNA_sequences)
+    cds_start_dict = {}
+    cds_end_dict = {}
+    seq_dict = {}
+    for line in in_seq_handle:
+        if line[0] != ">":
+            seq_dict.setdefault(transcript, "")
+            seq_dict[transcript] += line[:-1]
+            continue
+        try:
+            transcript_split = line[:-1].split("\t")
+            transcript = transcript_split[0][1:]
+            cds_start_dict[transcript] = int(transcript_split[1])
+            cds_end_dict[transcript] = int(transcript_split[2])
+        except:
+            pass
+    in_seq_handle.close()
+
+    offset = args.offset
+    readlen_range = args.lengths
+    readlen_rangesplit = readlen_range.split(":")
+    if len(readlen_rangesplit) == 1:
+        accepted_read_lengths = [int(readlen_rangesplit[0])]
+        length_values = "%s" % int(readlen_rangesplit[0])
+    elif len(readlen_rangesplit) == 2:
+        accepted_read_lengths = [
+            readlen
+            for readlen in range(
+                int(readlen_rangesplit[0]), int(readlen_rangesplit[1]) + 1
+            )
+        ]
+        length_values = "%s_%s" % (
+            int(readlen_rangesplit[0]),
+            int(readlen_rangesplit[1]),
+        )
+    else:
+        stop_err(
+            "Lengths of footprints parameter not in correct format, it should be either colon seperated with the second value greater or equal to the first, (28:32) or a single interger (31)"
+        )
+    if len(accepted_read_lengths) == 0:
+        stop_err(
+            "Lengths of footprints parameter not in correct format, it should be either colon seperated with the second value greater or equal to the first, (28:32) or a single interger (31)"
+        )
+
+    nts = ["A", "G", "C", "T"]
+    aligments_A1 = pysam.Samfile(args.alignment, "rb")
+
+    nucleotide_enrichment_dict = {}
+    nucleotide_enrichment_expected_dict = {}
+    for nt in nts:
+        nucleotide_enrichment_dict[nt] = {}
+        nucleotide_enrichment_expected_dict[nt] = []
+        for number in range(0, 180, 1):
+            nucleotide_enrichment_dict[nt][number] = [0.0, 0.0]
+
+    list_transcripts = seq_dict.keys()
+    number_transcripts = 0
+    list_10_percentile = []
+    for value in range(1, 10):
+        list_10_percentile.append((len(list_transcripts) * value) / 10)
+    for transcript in list_transcripts:
+        number_transcripts += 1
+        if number_transcripts in list_10_percentile:
+            sys.stdout.write(
+                "%s percent\n"
+                % ((list_10_percentile.index(number_transcripts) + 1) * 10)
+            )
+
+        try:  # use supplied CDS annotation
+            cds_start = cds_start_dict[transcript]
+            cds_end = cds_end_dict[transcript]
+            if cds_end < cds_start:
+                raise Exception
+        except Exception:  # find longest ORF
+            transcript_seq = seq_dict[transcript]
+            cds_start = -1
+            start_post = []
+            end_post = []
+            for match in re.finditer(r"(?=(%s))" % re.escape("ATG"), transcript_seq):
+                start_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TAG"), transcript_seq):
+                end_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TAA"), transcript_seq):
+                end_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TGA"), transcript_seq):
+                end_post.append(match.start())
+
+            end_post.sort()
+            len_max_orf = 0
+            for value in start_post:
+                for value2 in end_post:
+                    if value < value2:
+                        if value % 3 == value2 % 3:
+                            len_orf = value2 - value
+                            if len_orf > len_max_orf:
+                                cds_start = value
+                                cds_end = value2 + 3
+                                len_max_orf = len_orf
+                            break
+            if cds_start == -1:
+                # sys.stdout.write( '%s, AUG codon not found\n'%transcript  )
+                continue
+        elongation_region_all = seq_dict[transcript][cds_start:cds_end]
+        elongation_region_part = elongation_region_all[
+            120:-60
+        ]  # first 120 and last 60 nt are not used
+        # peptide_sequence       = elongation_region_all.translate()
+
+        if len(elongation_region_part) % 3 != 0:
+            # sys.stdout.write( '%s, CDS not divisible by 3\n'%transcript  )
+            continue
+        profile_list = [
+            0.0 for n in range(cds_start + 120, cds_end - 60)
+        ]  # records ribo-seq profile
+        if len(profile_list) < 50:
+            # sys.stdout.write( '%s, ORF too short\n'%transcript  )
+            continue
+        all_reads = aligments_A1.fetch(transcript)
+
+        len_elongation_region = len(profile_list)
+        for read in all_reads:
+            readlen = read.qlen
+            if readlen not in accepted_read_lengths:
+                continue  # selection of read of acceptable length
+            A_site = read.pos + offset - cds_start - 120  # addition of offset
+            if len_elongation_region > A_site > -1:
+                profile_list[A_site] += 1
+
+        average_gene_density = float(sum(profile_list)) / len(profile_list)
+
+        if average_gene_density != 0:
+            num_codon = len(
+                [
+                    1
+                    for number88 in range(0, len(profile_list), 3)
+                    if (
+                        (
+                            profile_list[number88]
+                            + profile_list[number88 + 1]
+                            + profile_list[number88 + 2]
+                        )
+                        / 3
+                    )
+                    > average_gene_density
+                ]
+            )
+            # number of codons that exceed average gene density
+            expected_codon_density = float(num_codon) / (len(profile_list) / 3)
+
+            codon_start = 0
+            for sliding_w_n in range(
+                0, len(elongation_region_part), 3
+            ):  # sliding window using increments of 3 nts
+                codon_window = str(
+                    elongation_region_all[codon_start : codon_start + 180]
+                )
+                if len(set(codon_window) - set(["A", "T", "G", "C"])) != 0:
+                    codon_start += 3
+                    continue
+
+                if (
+                    profile_list[sliding_w_n]
+                    + profile_list[sliding_w_n + 1]
+                    + profile_list[sliding_w_n + 2]
+                ) / 3 > average_gene_density:
+                    for number in range(0, 180):
+                        nucleotide3 = codon_window[number]
+                        nucleotide_enrichment_dict[nucleotide3][number][0] += 1
+                        nucleotide_enrichment_dict[nucleotide3][number][1] += 1
+                else:
+                    for number in range(0, 180):
+                        nucleotide3 = codon_window[number]
+                        nucleotide_enrichment_dict[nucleotide3][number][0] += 1
+
+                nucleotide3 = codon_window[120:121]
+                nucleotide_enrichment_expected_dict[nucleotide3].append(
+                    expected_codon_density
+                )
+                nucleotide3 = codon_window[121:122]
+                nucleotide_enrichment_expected_dict[nucleotide3].append(
+                    expected_codon_density
+                )
+                nucleotide3 = codon_window[122:123]
+                nucleotide_enrichment_expected_dict[nucleotide3].append(
+                    expected_codon_density
+                )
+                codon_start += 3
+
+    if not os.path.exists(args.Path):
+        os.mkdir(args.Path)
+    alignment_filename = args.alignment.split("/")[-1]
+    outfile = open(
+        "%s/RUST_nucleotide_file_%s_%s_%s"
+        % (args.Path, alignment_filename, args.offset, length_values),
+        "w",
+    )
+    outfile.write("nucleotide, expected value")
+    for number106 in range(-120, 60):
+        outfile.write(", %s" % number106)
+    outfile.write("\n")
+
+    list_nucleotide2 = []
+    nucleotides = list(nucleotide_enrichment_expected_dict.keys())
+    nucleotides.sort()
+    rust_expected = []
+    rust_observed_metafootprint = []
+    for nucleotide2 in nucleotides:
+        if nucleotide2 in list_nucleotide2:
+            continue
+        list_nucleotide2.append(nucleotide2)
+        outfile.write("%s" % nucleotide2)
+        outfile.write(
+            ", %s" % mean_value(nucleotide_enrichment_expected_dict[nucleotide2])
+        )
+        list_data = []
+        for number in range(0, 180):
+            if nucleotide_enrichment_dict[nucleotide2][number][0] != 0:
+                outfile.write(
+                    ", %s"
+                    % (
+                        nucleotide_enrichment_dict[nucleotide2][number][1]
+                        / nucleotide_enrichment_dict[nucleotide2][number][0]
+                    )
+                )
+                list_data.append(
+                    nucleotide_enrichment_dict[nucleotide2][number][1]
+                    / nucleotide_enrichment_dict[nucleotide2][number][0]
+                )
+            else:
+                outfile.write(", 0")
+                list_data.append(0)
+        rust_expected.append(
+            mean_value(nucleotide_enrichment_expected_dict[nucleotide2])
+        )
+        rust_observed_metafootprint.append(list_data)
+        outfile.write("\n")
+
+    rust_expected_sum = sum(rust_expected)
+    q_values = [n / rust_expected_sum for n in rust_expected]
+    shannon_values = []
+    for loc_i in range(180):
+        rust_observed = [n[loc_i] for n in rust_observed_metafootprint]
+        rust_observed_sum = sum(rust_observed)
+        rust_observed_min = min(rust_observed)
+        if rust_observed_min == 0:
+            shannon_values.append("NA")
+        else:
+            p_values = [n / rust_observed_sum for n in rust_observed]
+            shannon = []
+            list_normalised = []  ####
+            for p_value, q_value in zip(p_values, q_values):
+                shannon.append(abs(p_value * math.log((p_value / q_value), 2)))
+                list_normalised.append(p_value / q_value)  ####
+            shannon_values.append(sum(shannon))
+
+    outfile.write("\nKullback Leibler divergence,")
+    for value in shannon_values:
+        outfile.write(", %s" % value)
+    outfile.close()
+
+    try:
+        mpl.rcParams["xtick.direction"] = "out"
+        mpl.rcParams["ytick.direction"] = "out"
+        mpl.rcParams["legend.fontsize"] = 10
+        mpl.rcParams["ytick.labelsize"] = 10
+        mpl.rcParams["xtick.labelsize"] = 10
+        mpl.rcParams["font.size"] = 10
+        mpl.rcParams["axes.titlesize"] = 10
+        mpl.rcParams["legend.frameon"] = 0
+        mpl.rcParams["axes.axisbelow"] = False
+        mpl.rcParams["xtick.major.pad"] = 2.0
+        mpl.rcParams["ytick.major.pad"] = 2
+        mpl.rcParams["xtick.major.size"] = 2.0
+        mpl.rcParams["ytick.major.size"] = 2
+        mpl.rcParams["axes.linewidth"] = 0.5
+        mpl.rcParams["ytick.major.width"] = 0.25
+        mpl.rcParams["xtick.major.width"] = 0.25
+        mpl.rcParams["lines.linewidth"] = 1
+        mpl.rcParams["legend.borderpad"] = 0.01
+        mpl.rcParams["legend.labelspacing"] = 0.05
+        mpl.rcParams["legend.columnspacing"] = 0.5
+        mpl.rcParams["legend.borderaxespad"] = 0.15
+        mpl.rcParams["legend.handlelength"] = 1
+
+        fig = plt.figure(figsize=(6.69, 6.0))
+        infileopen = open(
+            "%s/RUST_nucleotide_file_%s_%s_%s"
+            % (args.Path, alignment_filename, args.offset, length_values)
+        )
+        ax1_metafootprint = fig.add_subplot(111)
+        RUST_metagene_plot(infileopen, ax1_metafootprint)
+        plt.savefig(
+            "%s/RUST_nucleotide_metafootprint_%s_%s_%s.png"
+            % (args.Path, alignment_filename, args.offset, length_values)
+        )
+    except:
+        sys.stdout.write("Error producing images\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Produces RUST metagene profile of nucleotides"
+    )
+    parser.add_argument(
+        "-t",
+        "--transcriptome",
+        help="fasta file of transcripts, CDS start and end may be provided on description line using tab separation e.g. >NM_0001  10  5000, otherwise it searches for longest ORF"
+        ", required=True",
+    )
+    parser.add_argument(
+        "-a",
+        "--alignment",
+        help="sorted bam file of transcriptome alignments",
+        required=True,
+    )
+    parser.add_argument("-o", "--offset", help="nucleotide offset to A-site", type=int)
+    parser.add_argument(
+        "-l",
+        "--lengths",
+        help="lengths of footprints included, for example 28:32 is 28,29,30,31,32",
+    )
+    parser.add_argument(
+        "-P",
+        "--Path",
+        help='path to outputfile, default is "nucleotide"',
+        default="nucleotide",
+    )
+    parser.add_argument("--version", action="version", version="%(prog)s 1.2")
+    args = parser.parse_args(None)
+
+    main(args)

falcon/lib/python3.10/site-packages/RUST/predict_profiles.py

@@ -0,0 +1,356 @@
+#!/usr/bin/python
+#####################################################################################
+# rust_predict_profiles, Correlation between observed and predicted profiles from CDS start + 120 to CDS stop - 60
+# Copyright (C) 2015 Patrick O'Connor
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#####################################################################################
+
+import os, pysam, sys, numpy, argparse, re
+from RUST.methods import *
+
+
+def rank(lsit1):
+    lsit2 = []
+    lsit1s = lsit1[:]
+    lsit1s.sort()
+    dict_ranks = {}
+    for value_i, value in enumerate(lsit1s):
+        dict_ranks.setdefault(value, []).append(value_i)
+
+    for value in lsit1:
+        lsit2.append(mean_value(dict_ranks[value]))
+    return lsit2
+
+
+def main(args):
+
+    RUST_file = open(args.rustfile)  # file output of RUST_script.py
+    RUST_file.readline()
+    codon_rust_dict = {}
+    for line in RUST_file:
+        linesplit = line.split(",")
+        if len(linesplit) == 1:
+            break
+        codon = linesplit[0]
+        if len(codon) != 3 or len(set(codon) - set(["A", "T", "G", "C"])) != 0:
+            stop_err("Codon metafootprint file not correct, check input file")
+        codon_rust_dict[codon] = {}
+        rust_values = list(map(float, linesplit[1:]))
+        expected = rust_values[0]
+        rust_metafootprint = [ro_value / expected for ro_value in rust_values[1:]]
+        for n in range(34, 46):
+            codon_rust_dict[codon][n - 40] = rust_metafootprint[
+                n
+            ]  # for 12 codons positions near A-site
+    RUST_file.close()
+
+    mRNA_sequences = args.transcriptome  # path to fastq file of transcripts
+    in_seq_handle = open(mRNA_sequences)
+    cds_start_dict = {}
+    cds_end_dict = {}
+    seq_dict = {}
+    for line in in_seq_handle:
+        if line[0] != ">":
+            seq_dict.setdefault(transcript, "")
+            seq_dict[transcript] += line[:-1]
+            continue
+        try:
+            transcript_split = line[:-1].split("\t")
+            transcript = transcript_split[0][1:]
+            cds_start_dict[transcript] = int(transcript_split[1])
+            cds_end_dict[transcript] = int(transcript_split[2])
+        except:
+            pass
+    in_seq_handle.close()
+
+    offset = args.offset
+    readlen_range = args.lengths
+    readlen_rangesplit = readlen_range.split(":")
+    if len(readlen_rangesplit) == 1:
+        accepted_read_lengths = [int(readlen_rangesplit[0])]
+        length_values = "%s" % int(readlen_rangesplit[0])
+    elif len(readlen_rangesplit) == 2:
+        accepted_read_lengths = [
+            readlen
+            for readlen in range(
+                int(readlen_rangesplit[0]), int(readlen_rangesplit[1]) + 1
+            )
+        ]
+        length_values = "%s_%s" % (
+            int(readlen_rangesplit[0]),
+            int(readlen_rangesplit[1]),
+        )
+    else:
+        stop_err(
+            "Lengths of footprints parameter not in correct format, it should be either colon seperated with the second value greater or equal to the first, (28:32) or a single interger (31)"
+        )
+    if len(accepted_read_lengths) == 0:
+        stop_err(
+            "Lengths of footprints parameter not in correct format, it should be either colon seperated with the second value greater or equal to the first, (28:32) or a single interger (31)"
+        )
+
+    amino_acids = [
+        "A",
+        "C",
+        "E",
+        "D",
+        "G",
+        "F",
+        "I",
+        "H",
+        "K",
+        "M",
+        "L",
+        "N",
+        "Q",
+        "P",
+        "S",
+        "R",
+        "T",
+        "W",
+        "V",
+        "Y",
+    ]
+    aligments_A1 = pysam.Samfile(args.alignment, "rb")
+
+    if not os.path.exists(args.Path):
+        os.mkdir(args.Path)
+    if args.profiles:
+        if not os.path.exists("%s/rust_profile_predictions" % args.Path):
+            os.mkdir("%s/rust_profile_predictions" % args.Path)
+
+    if "/" in args.rustfile:
+        rustfile_split = args.rustfile.split("/")[-1]
+    # elif "\\" in args.rustfile:
+    # rustfile_split= args.rustfile.split("\\")[-1]
+    else:
+        rustfile_split = args.rustfile
+
+    if "RUST_codon_file_" in rustfile_split:
+        alignment_filename = rustfile_split[16:]
+    else:
+        alignment_filename = rustfile_split
+
+    correlations_file = open(
+        "%s/predict_profiles_%s_%s_%s"
+        % (args.Path, alignment_filename, args.offset, length_values),
+        "w",
+    )
+    correlations_file.write(
+        "transcript,average read density,Spearman's coefficient,Pearson's coefficient\n"
+    )
+
+    list_transcripts = seq_dict.keys()
+    number_transcripts = 0
+    list_10_percentile = []
+    for value in range(1, 10):
+        list_10_percentile.append((len(list_transcripts) * value) / 10)
+    for transcript in list_transcripts:
+        number_transcripts += 1
+        if number_transcripts in list_10_percentile:
+            sys.stdout.write(
+                "%s percent\n"
+                % ((list_10_percentile.index(number_transcripts) + 1) * 10)
+            )
+
+        try:
+            cds_start = cds_start_dict[transcript]
+            cds_end = cds_end_dict[transcript]
+            if cds_end < cds_start:
+                raise Exception
+        except Exception:
+            transcript_seq = seq_dict[transcript]
+            cds_start = -1
+            start_post = []
+            end_post = []
+            for match in re.finditer(r"(?=(%s))" % re.escape("ATG"), transcript_seq):
+                start_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TAG"), transcript_seq):
+                end_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TAA"), transcript_seq):
+                end_post.append(match.start())
+            for match in re.finditer(r"(?=(%s))" % re.escape("TGA"), transcript_seq):
+                end_post.append(match.start())
+
+            end_post.sort()
+            len_max_orf = 0
+            for value in start_post:
+                for value2 in end_post:
+                    if value < value2:
+                        if value % 3 == value2 % 3:
+                            len_orf = value2 - value
+                            if len_orf > len_max_orf:
+                                cds_start = value
+                                cds_end = value2 + 3
+                                len_max_orf = len_orf
+                            break
+            if cds_start == -1:
+                # sys.stdout.write( '%s, AUG codon not found\n'%transcript  )
+                continue
+
+        elongation_region_all = seq_dict[transcript][cds_start:cds_end]
+
+        if (
+            len(elongation_region_all) % 3 != 0
+        ):  # genes with codon region not divisible by 3 skipped
+            # sys.stdout.write( '%s, CDS not divisible by 3\n'%transcript  )
+            continue
+
+        profile_expect = []
+        for n in range(
+            0, len(elongation_region_all[120:-60]), 3
+        ):  # predicts profile from 120 nts after start to 60 before stop
+            minus6_plus5_footprint = elongation_region_all[
+                120 + n - 18 : 120 + n + 19
+            ]  # contains sequence of region used to predict profile
+            value = 1.0
+            amino_loc = -6
+            for number in range(0, len(minus6_plus5_footprint) - 2, 3):
+                codon = minus6_plus5_footprint[number : number + 3]
+                if len(set(codon) - set(["A", "T", "G", "C"])) != 0 or codon in [
+                    "TAG",
+                    "TGA",
+                    "TAA",
+                ]:
+                    amino_loc += 1
+                    continue
+                value = value * codon_rust_dict[codon][amino_loc]
+                amino_loc += 1
+            profile_expect.append(value)
+        profile_expect_sum = sum(profile_expect)
+        profile_expect_probablility = [
+            float(value) / profile_expect_sum for value in profile_expect
+        ]
+
+        profile_list = [
+            0.0 for n in range(cds_start + 120, cds_end - 60)
+        ]  # records ribo-seq profile
+        if len(profile_list) < 50:
+            # sys.stdout.write( '%s, ORF too short\n'%transcript  )
+            continue
+        all_reads = aligments_A1.fetch(transcript)
+
+        len_elongation_region = len(profile_list)
+        for read in all_reads:
+            readlen = read.qlen
+            if readlen not in accepted_read_lengths:
+                continue  # selection of read of acceptable length
+            A_site = read.pos + offset - cds_start - 120  # addition of offset
+            if len_elongation_region > A_site > -1:
+                profile_list[A_site] += 1
+
+        average_gene_density = float(sum(profile_list)) / len(
+            profile_list
+        )  # average gene density calculated
+        if average_gene_density > 0:
+            profiles_control_codon = [
+                profile_list[codon_ind]
+                + profile_list[codon_ind + 1]
+                + profile_list[codon_ind + 2]
+                for codon_ind in range(0, len(profile_list), 3)
+            ]
+            spearmanr_value = numpy.corrcoef(
+                rank(profiles_control_codon), rank(profile_expect)
+            )[0, 1]
+            pearsonr_value = numpy.corrcoef(profiles_control_codon, profile_expect)[
+                0, 1
+            ]
+            correlations_file.write(
+                "%s,%s,%s,%s\n"
+                % (transcript, average_gene_density, spearmanr_value, pearsonr_value)
+            )
+            if args.profiles:
+                open_file = open(
+                    "%s/rust_profile_predictions/observed_predicted_%s_%s_%s_%s.csv"
+                    % (
+                        args.Path,
+                        transcript,
+                        alignment_filename,
+                        args.offset,
+                        length_values,
+                    ),
+                    "w",
+                )
+                profile_expect_probablility_index = 0
+                open_file.write("%s\n" % transcript)
+                open_file.write("codon, predicted probability, alignments\n")
+                for coordinate_index in range(
+                    0, len(elongation_region_all[120:-60]), 3
+                ):
+                    codon = elongation_region_all[
+                        120 + coordinate_index : 120 + coordinate_index + 3
+                    ]
+                    open_file.write("%s, " % (codon))
+                    open_file.write(
+                        "%s, "
+                        % (
+                            profile_expect_probablility[
+                                profile_expect_probablility_index
+                            ]
+                        )
+                    )
+                    open_file.write(
+                        "%s\n"
+                        % (profiles_control_codon[profile_expect_probablility_index])
+                    )
+                    profile_expect_probablility_index += 1
+                open_file.close()
+    correlations_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Correlation between observed and predicted profiles from CDS start + 120 to CDS stop - 60"
+    )
+    parser.add_argument(
+        "-t",
+        "--transcriptome",
+        help="fasta file of transcripts, CDS start and end may be provided on description line using tab separation e.g. >NM_0001  10  5000, otherwise it searches for longest ORF"
+        ", required=True",
+    )
+    parser.add_argument(
+        "-a",
+        "--alignment",
+        help="sorted bam file of transcriptome alignments",
+        required=True,
+    )
+    parser.add_argument("-o", "--offset", help="nucleotide offset to A-site", type=int)
+    parser.add_argument(
+        "-l",
+        "--lengths",
+        help="lengths of footprints included, for example 28:32 is 28,29,30,31,32",
+    )
+    parser.add_argument(
+        "-P",
+        "--Path",
+        help='path to outputfile, default is "amino"',
+        default="predict_profiles",
+    )
+    parser.add_argument("-r", "--rustfile", help="path to rust file produced by codon")
+    parser.add_argument(
+        "-o",
+        metavar="outfile directory",
+        help='path to outputfile, default is "predict_profiles"',
+        default="predict_profiles",
+    )
+    parser.add_argument(
+        "-p",
+        action="store_true",
+        help="writes all profiles in csv files, may produce >10,000 files",
+        default=False,
+    )
+    parser.add_argument("--version", action="version", version="%(prog)s 1.2")
+    args = parser.parse_args(None)
+    main(args)

falcon/lib/python3.10/site-packages/setuptools/command/build_clib.py

@@ -0,0 +1,103 @@
+from ..dist import Distribution
+from ..modified import newer_pairwise_group
+
+import distutils.command.build_clib as orig
+from distutils import log
+from distutils.errors import DistutilsSetupError
+
+
+class build_clib(orig.build_clib):
+    """
+    Override the default build_clib behaviour to do the following:
+
+    1. Implement a rudimentary timestamp-based dependency system
+       so 'compile()' doesn't run every time.
+    2. Add more keys to the 'build_info' dictionary:
+        * obj_deps - specify dependencies for each object compiled.
+                     this should be a dictionary mapping a key
+                     with the source filename to a list of
+                     dependencies. Use an empty string for global
+                     dependencies.
+        * cflags   - specify a list of additional flags to pass to
+                     the compiler.
+    """
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def build_libraries(self, libraries) -> None:
+        for lib_name, build_info in libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'sources' must be present and must be "
+                    "a list of source filenames"
+                )
+            sources = sorted(list(sources))
+
+            log.info("building '%s' library", lib_name)
+
+            # Make sure everything is the correct type.
+            # obj_deps should be a dictionary of keys as sources
+            # and a list/tuple of files that are its dependencies.
+            obj_deps = build_info.get('obj_deps', dict())
+            if not isinstance(obj_deps, dict):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'"
+                )
+            dependencies = []
+
+            # Get the global dependencies that are specified by the '' key.
+            # These will go into every source's dependency list.
+            global_deps = obj_deps.get('', list())
+            if not isinstance(global_deps, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'"
+                )
+
+            # Build the list to be used by newer_pairwise_group
+            # each source will be auto-added to its dependencies.
+            for source in sources:
+                src_deps = [source]
+                src_deps.extend(global_deps)
+                extra_deps = obj_deps.get(source, list())
+                if not isinstance(extra_deps, (list, tuple)):
+                    raise DistutilsSetupError(
+                        f"in 'libraries' option (library '{lib_name}'), "
+                        "'obj_deps' must be a dictionary of "
+                        "type 'source: list'"
+                    )
+                src_deps.extend(extra_deps)
+                dependencies.append(src_deps)
+
+            expected_objects = self.compiler.object_filenames(
+                sources,
+                output_dir=self.build_temp,
+            )
+
+            if newer_pairwise_group(dependencies, expected_objects) != ([], []):
+                # First, compile the source code to object files in the library
+                # directory.  (This should probably change to putting object
+                # files in a temporary build directory.)
+                macros = build_info.get('macros')
+                include_dirs = build_info.get('include_dirs')
+                cflags = build_info.get('cflags')
+                self.compiler.compile(
+                    sources,
+                    output_dir=self.build_temp,
+                    macros=macros,
+                    include_dirs=include_dirs,
+                    extra_postargs=cflags,
+                    debug=self.debug,
+                )
+
+            # Now "link" the object files together into a static library.
+            # (On Unix at least, this isn't really linking -- it just
+            # builds an archive.  Whatever.)
+            self.compiler.create_static_lib(
+                expected_objects, lib_name, output_dir=self.build_clib, debug=self.debug
+            )

falcon/lib/python3.10/site-packages/setuptools/command/install.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import glob
+import inspect
+import platform
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar, cast
+
+import setuptools
+
+from ..dist import Distribution
+from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+from .bdist_egg import bdist_egg as bdist_egg_cls
+
+import distutils.command.install as orig
+from distutils.errors import DistutilsArgError
+
+if TYPE_CHECKING:
+    # This is only used for a type-cast, don't import at runtime or it'll cause deprecation warnings
+    from .easy_install import easy_install as easy_install_cls
+else:
+    easy_install_cls = None
+
+
+def __getattr__(name: str):  # pragma: no cover
+    if name == "_install":
+        SetuptoolsDeprecationWarning.emit(
+            "`setuptools.command._install` was an internal implementation detail "
+            + "that was left in for numpy<1.9 support.",
+            due_date=(2025, 5, 2),  # Originally added on 2024-11-01
+        )
+        return orig.install
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+class install(orig.install):
+    """Use easy_install to install the package, w/dependencies"""
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    user_options = orig.install.user_options + [
+        ('old-and-unmanageable', None, "Try not to use this!"),
+        (
+            'single-version-externally-managed',
+            None,
+            "used by system package builders to create 'flat' eggs",
+        ),
+    ]
+    boolean_options = orig.install.boolean_options + [
+        'old-and-unmanageable',
+        'single-version-externally-managed',
+    ]
+    # Type the same as distutils.command.install.install.sub_commands
+    # Must keep the second tuple item potentially None due to invariance
+    new_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]] = [
+        ('install_egg_info', lambda self: True),
+        ('install_scripts', lambda self: True),
+    ]
+    _nc = dict(new_commands)
+
+    def initialize_options(self):
+        SetuptoolsDeprecationWarning.emit(
+            "setup.py install is deprecated.",
+            """
+            Please avoid running ``setup.py`` directly.
+            Instead, use pypa/build, pypa/installer or other
+            standards-based tools.
+            """,
+            see_url="https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html",
+            # TODO: Document how to bootstrap setuptools without install
+            #       (e.g. by unziping the wheel file)
+            #       and then add a due_date to this warning.
+        )
+
+        super().initialize_options()
+        self.old_and_unmanageable = None
+        self.single_version_externally_managed = None
+
+    def finalize_options(self) -> None:
+        super().finalize_options()
+        if self.root:
+            self.single_version_externally_managed = True
+        elif self.single_version_externally_managed:
+            if not self.root and not self.record:
+                raise DistutilsArgError(
+                    "You must specify --record or --root when building system packages"
+                )
+
+    def handle_extra_path(self):
+        if self.root or self.single_version_externally_managed:
+            # explicit backward-compatibility mode, allow extra_path to work
+            return orig.install.handle_extra_path(self)
+
+        # Ignore extra_path when installing an egg (or being run by another
+        # command without --root or --single-version-externally-managed
+        self.path_file = None
+        self.extra_dirs = ''
+        return None
+
+    def run(self):
+        # Explicit request for old-style install?  Just do it
+        if self.old_and_unmanageable or self.single_version_externally_managed:
+            return super().run()
+
+        if not self._called_from_setup(inspect.currentframe()):
+            # Run in backward-compatibility mode to support bdist_* commands.
+            super().run()
+        else:
+            self.do_egg_install()
+
+        return None
+
+    @staticmethod
+    def _called_from_setup(run_frame):
+        """
+        Attempt to detect whether run() was called from setup() or by another
+        command.  If called by setup(), the parent caller will be the
+        'run_command' method in 'distutils.dist', and *its* caller will be
+        the 'run_commands' method.  If called any other way, the
+        immediate caller *might* be 'run_command', but it won't have been
+        called by 'run_commands'. Return True in that case or if a call stack
+        is unavailable. Return False otherwise.
+        """
+        if run_frame is None:
+            msg = "Call stack not available. bdist_* commands may fail."
+            SetuptoolsWarning.emit(msg)
+            if platform.python_implementation() == 'IronPython':
+                msg = "For best results, pass -X:Frames to enable call stack."
+                SetuptoolsWarning.emit(msg)
+            return True
+
+        frames = inspect.getouterframes(run_frame)
+        for frame in frames[2:4]:
+            (caller,) = frame[:1]
+            info = inspect.getframeinfo(caller)
+            caller_module = caller.f_globals.get('__name__', '')
+
+            if caller_module == "setuptools.dist" and info.function == "run_command":
+                # Starting from v61.0.0 setuptools overwrites dist.run_command
+                continue
+
+            return caller_module == 'distutils.dist' and info.function == 'run_commands'
+
+        return False
+
+    def do_egg_install(self) -> None:
+        easy_install = self.distribution.get_command_class('easy_install')
+
+        cmd = cast(
+            # We'd want to cast easy_install as type[easy_install_cls] but a bug in
+            # mypy makes it think easy_install() returns a Command on Python 3.12+
+            # https://github.com/python/mypy/issues/18088
+            easy_install_cls,
+            easy_install(  # type: ignore[call-arg]
+                self.distribution,
+                args="x",
+                root=self.root,
+                record=self.record,
+            ),
+        )
+        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd
+        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed
+
+        # pick up setup-dir .egg files only: no .egg-info
+        cmd.package_index.scan(glob.glob('*.egg'))
+
+        self.run_command('bdist_egg')
+        bdist_egg = cast(bdist_egg_cls, self.distribution.get_command_obj('bdist_egg'))
+        args = [bdist_egg.egg_output]
+
+        if setuptools.bootstrap_install_from:
+            # Bootstrap self-installation of setuptools
+            args.insert(0, setuptools.bootstrap_install_from)
+
+        cmd.args = args
+        cmd.run(show_deprecation=False)
+        setuptools.bootstrap_install_from = None
+
+
+# XXX Python 3.1 doesn't see _nc if this is inside the class
+install.sub_commands = [
+    cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc
+] + install.new_commands

falcon/lib/python3.10/site-packages/svgwrite/animate.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman --<mozman@gmx.at>
+# Purpose: animate elements
+# Created: 31.10.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+
+from svgwrite.base import BaseElement
+from svgwrite.mixins import XLink
+from svgwrite.utils import strlist, is_string
+
+
+class Set(BaseElement, XLink):
+    """ The **set** element provides a simple means of just setting the value
+    of an attribute for a specified duration. It supports all attribute types,
+    including those that cannot reasonably be interpolated, such as string
+    and boolean values. The **set** element is non-additive. The additive and
+    accumulate attributes are not allowed, and will be ignored if specified.
+    """
+    elementname = 'set'
+
+    def __init__(self, href=None, **extra):
+        """ Set constructor.
+
+        :param href: target svg element, if **href** is not `None`; else
+            the target SVG Element is the parent SVG Element.
+        """
+        super(Set, self).__init__(**extra)
+        if href is not None:
+            self.set_href(href)
+
+    def get_xml(self):
+        self.update_id() # if href is an object - 'id' - attribute may be changed!
+        return super(Set, self).get_xml()
+
+    def set_target(self, attributeName, attributeType=None):
+        """
+        Set animation attributes :ref:`attributeName` and :ref:`attributeType`.
+        """
+        self['attributeName'] = attributeName
+        if attributeType is not None:
+            self['attributeType'] = attributeType
+
+
+    def set_event(self, onbegin=None, onend=None, onrepeat=None, onload=None):
+        """
+        Set animation attributes :ref:`onbegin`, :ref:`onend`, :ref:`onrepeat`
+        and :ref:`onload`.
+        """
+        if onbegin is not None:
+            self['onbegin'] = onbegin
+        if onend is not None:
+            self['onend'] = onend
+        if onrepeat is not None:
+            self['onrepeat'] = onrepeat
+        if onload is not None:
+            self['onload'] = onload
+
+    def set_timing(self, begin=None, end=None, dur=None, min=None, max=None,
+                   restart=None, repeatCount=None, repeatDur=None):
+        """
+        Set animation attributes :ref:`begin`, :ref:`end`, :ref:`dur`,
+        :ref:`min`, :ref:`max`, :ref:`restart`, :ref:`repeatCount` and
+        :ref:`repeatDur`.
+        """
+        if begin is not None:
+            self['begin'] = begin
+        if end is not None:
+            self['end'] = end
+        if dur is not None:
+            self['dur'] = dur
+        if min is not None:
+            self['min'] = min
+        if max is not None:
+            self['max'] = max
+        if restart is not None:
+            self['restart'] = restart
+        if repeatCount is not None:
+            self['repeatCount'] = repeatCount
+        if repeatDur is not None:
+            self['repeatDur'] = repeatDur
+
+    def freeze(self):
+        """ Freeze the animation effect. (see also :ref:`fill <animateFill>`)
+        """
+        self['fill'] = 'freeze'
+
+class AnimateMotion(Set):
+    """ The **animateMotion** element causes a referenced element to move
+    along a motion path.
+    """
+    elementname = 'animateMotion'
+
+    def __init__(self, path=None, href=None, **extra):
+        """
+        :param path: the motion path
+        :param href: target svg element, if **href** is not `None`; else
+          the target SVG Element is the parent SVG Element.
+        """
+        super(AnimateMotion, self).__init__(href=href, **extra)
+        if path is not None:
+            self['path'] = path
+
+    def set_value(self, path=None, calcMode=None, keyPoints=None, rotate=None):
+        """
+        Set animation attributes `path`, `calcMode`, `keyPoints` and `rotate`.
+        """
+        if path is not None:
+            self['path'] = path
+        if calcMode is not None:
+            self['calcMode'] = calcMode
+        if keyPoints is not None:
+            self['keyPoints'] = keyPoints
+        if rotate is not None:
+            self['rotate'] = rotate
+
+
+class Animate(Set):
+    """ The **animate** element allows scalar attributes and properties to be
+    assigned different values over time .
+    """
+    elementname = 'animate'
+
+    def __init__(self, attributeName=None, values=None, href=None, **extra):
+        """
+        :param attributeName: name of the SVG Attribute to animate
+        :param values: interpolation values, `string` as `<semicolon-list>` or a python `list`
+        :param href: target svg element, if **href** is not `None`; else
+          the target SVG Element is the parent SVG Element.
+        """
+        super(Animate, self).__init__(href=href, **extra)
+        if values is not None:
+            self.set_value(values)
+        if attributeName is not None:
+            self.set_target(attributeName)
+
+    def set_value(self, values, calcMode=None, keyTimes=None, keySplines=None,
+                  from_=None, to=None, by=None):
+        """
+        Set animation attributes :ref:`values`, :ref:`calcMode`, :ref:`keyTimes`,
+        :ref:`keySplines`, :ref:`from`, :ref:`to` and :ref:`by`.
+        """
+        if values is not None:
+            if not is_string(values):
+                values = strlist(values, ';')
+            self['values'] = values
+
+        if calcMode is not None:
+            self['calcMode'] = calcMode
+        if keyTimes is not None:
+            self['keyTimes'] = keyTimes
+        if keySplines is not None:
+            self['keySplines'] = keySplines
+        if from_ is not None:
+            self['from'] = from_
+        if to is not None:
+            self['to'] = to
+        if by is not None:
+            self['by'] = by
+
+
+class AnimateColor(Animate):
+    """ The **animateColor** element specifies a color transformation over
+    time.
+    """
+    elementname = 'animateColor'
+
+
+class AnimateTransform(Animate):
+    """ The **animateTransform** element animates a transformation attribute
+    on a target element, thereby allowing animations to control translation,
+    scaling, rotation and/or skewing.
+    """
+    elementname = 'animateTransform'
+    def __init__(self, transform, element=None, **extra):
+        """
+        :param element: target svg element, if element is not `None`; else
+          the target svg element is the parent svg element.
+        :param string transform: ``'translate | scale | rotate | skewX | skewY'``
+        """
+        super(AnimateTransform, self).__init__(element, **extra)
+        self['type'] = transform

falcon/lib/python3.10/site-packages/svgwrite/base.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman
+# Purpose: svg base element
+# Created: 08.09.2010
+# Copyright (c) 2010-2020, Manfred Moitzi
+# License: MIT License
+"""
+The **BaseElement** is the root for all SVG elements.
+"""
+
+from svgwrite.etree import etree
+
+import copy
+
+from svgwrite.params import Parameter
+from svgwrite.utils import AutoID
+
+
+class BaseElement(object):
+    """
+    The **BaseElement** is the root for all SVG elements. The SVG attributes
+    are stored in **attribs**, and the SVG subelements are stored in
+    **elements**.
+
+    """
+    elementname = 'baseElement'
+
+    def __init__(self, **extra):
+        """
+        :param extra: extra SVG attributes (keyword arguments)
+
+          * add trailing '_' to reserved keywords: ``'class_'``, ``'from_'``
+          * replace inner '-' by '_': ``'stroke_width'``
+
+
+        SVG attribute names will be checked, if **debug** is `True`.
+
+        workaround for removed **attribs** parameter in Version 0.2.2::
+
+            # replace
+            element = BaseElement(attribs=adict)
+
+            #by
+            element = BaseElement()
+            element.update(adict)
+
+        """
+        # the keyword 'factory' specifies the object creator
+        factory = extra.pop('factory', None)
+        if factory is not None:
+            # take parameter from 'factory'
+            self._parameter = factory._parameter
+        else:
+            # default parameter debug=True profile='full'
+            self._parameter = Parameter()
+
+        # override debug setting
+        debug = extra.pop('debug', None)
+        if debug is not None:
+            self._parameter.debug = debug
+
+        # override profile setting
+        profile = extra.pop('profile', None)
+        if profile is not None:
+            self._parameter.profile = profile
+
+        self.attribs = dict()
+        self.update(extra)
+        self.elements = list()
+
+    def update(self, attribs):
+        """ Update SVG Attributes from `dict` attribs.
+
+        Rules for keys:
+
+        1. trailing '_' will be removed (``'class_'`` -> ``'class'``)
+        2. inner '_' will be replaced by '-' (``'stroke_width'`` -> ``'stroke-width'``)
+
+        """
+        for key, value in attribs.items():
+            # remove trailing underscores
+            # and replace inner underscores
+            key = key.rstrip('_').replace('_', '-')
+            self.__setitem__(key, value)
+
+    def copy(self):
+        newobj = copy.copy(self)  # shallow copy of object
+        newobj.attribs = copy.copy(self.attribs)  # shallow copy of attributes
+        newobj.elements = copy.copy(self.elements)  # shallow copy of subelements
+        if 'id' in newobj.attribs:  # create a new 'id'
+            newobj['id'] = newobj.next_id()
+        return newobj
+
+    @property
+    def debug(self):
+        return self._parameter.debug
+
+    @property
+    def profile(self):
+        return self._parameter.profile
+
+    @property
+    def validator(self):
+        return self._parameter.validator
+
+    @validator.setter
+    def validator(self, value):
+        self._parameter.validator = value
+
+    @property
+    def version(self):
+        return self._parameter.get_version()
+
+    def set_parameter(self, parameter):
+        self._parameter = parameter
+
+    def next_id(self, value=None):
+        return AutoID.next_id(value)
+
+    def get_id(self):
+        """ Get the object `id` string, if the object does not have an `id`,
+        a new `id` will be created.
+
+        :returns: `string`
+        """
+        if 'id' not in self.attribs:
+            self.attribs['id'] = self.next_id()
+        return self.attribs['id']
+
+    def get_iri(self):
+        """
+        Get the `IRI` reference string of the object. (i.e., ``'#id'``).
+
+        :returns: `string`
+        """
+        return "#%s" % self.get_id()
+
+    def get_funciri(self):
+        """
+        Get the `FuncIRI` reference string of the object. (i.e. ``'url(#id)'``).
+
+        :returns: `string`
+        """
+        return "url(%s)" % self.get_iri()
+
+    def __getitem__(self, key):
+        """ Get SVG attribute by `key`.
+
+        :param string key: SVG attribute name
+        :return: SVG attribute value
+
+        """
+        return self.attribs[key]
+
+    def __setitem__(self, key, value):
+        """ Set SVG attribute by `key` to `value`.
+
+        :param string key: SVG attribute name
+        :param object value: SVG attribute value
+
+        """
+        # Attribute checking is only done by using the __setitem__() method or
+        # by self['attribute'] = value
+        if self.debug:
+            self.validator.check_svg_attribute_value(self.elementname, key, value)
+        self.attribs[key] = value
+
+    def add(self, element):
+        """ Add an SVG element as subelement.
+
+        :param element: append this SVG element
+        :returns: the added element
+
+        """
+        if self.debug:
+            self.validator.check_valid_children(self.elementname, element.elementname)
+        self.elements.append(element)
+        return element
+
+    def tostring(self):
+        """ Get the XML representation as unicode `string`.
+
+        :return: unicode XML string of this object and all its subelements
+
+        """
+        xml = self.get_xml()
+        # required for Python 2 support
+        xml_utf8_str = etree.tostring(xml, encoding='utf-8')
+        return xml_utf8_str.decode('utf-8')
+        # just Python 3: return etree.tostring(xml, encoding='unicode')
+    
+    def _repr_svg_(self):
+        """ Show SVG in IPython, Jupyter Notebook, and Jupyter Lab
+
+        :return: unicode XML string of this object and all its subelements
+
+        """
+        return self.tostring()
+
+    def get_xml(self):
+        """ Get the XML representation as `ElementTree` object.
+
+        :return: XML `ElementTree` of this object and all its subelements
+
+        """
+        xml = etree.Element(self.elementname)
+        if self.debug:
+            self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)
+        for attribute, value in sorted(self.attribs.items()):
+            # filter 'None' values
+            if value is not None:
+                value = self.value_to_string(value)
+                if value:  # just add not empty attributes
+                    xml.set(attribute, value)
+
+        for element in self.elements:
+            xml.append(element.get_xml())
+        return xml
+
+    def value_to_string(self, value):
+        """
+        Converts *value* into a <string> includes a value check, depending
+        on :attr:`self.debug` and :attr:`self.profile`.
+
+        """
+        if isinstance(value, (int, float)):
+            if self.debug:
+                self.validator.check_svg_type(value, 'number')
+            if isinstance(value, float) and self.profile == 'tiny':
+                value = round(value, 4)
+        return str(value)
+
+    def set_desc(self, title=None, desc=None):
+        """ Insert a **title** and/or a **desc** element as first subelement.
+        """
+        if desc is not None:
+            self.elements.insert(0, Desc(desc))
+        if title is not None:
+            self.elements.insert(0, Title(title))
+
+    def set_metadata(self, xmldata):
+        """
+        :param xmldata: an xml.etree.ElementTree - Element() object.
+        """
+        metadata = Metadata(xmldata)
+        if len(self.elements) == 0:
+            self.elements.append(metadata)
+        else:
+            pos = 0
+            while self.elements[pos].elementname in ('title', 'desc'):
+                pos += 1
+                if pos == len(self.elements):
+                    self.elements.append(metadata)
+                    return
+            if self.elements[pos].elementname == 'metadata':
+                self.elements[pos].xml.append(xmldata)
+            else:
+                self.elements.insert(pos, metadata)
+
+
+class Title(object):
+    elementname = 'title'
+
+    def __init__(self, text):
+        self.xml = etree.Element(self.elementname)
+        self.xml.text = str(text)
+
+    def get_xml(self):
+        return self.xml
+
+
+class Desc(Title):
+    elementname = 'desc'
+
+
+class Metadata(Title):
+    elementname = 'metadata'
+
+    def __init__(self, xmldata):
+        """
+        :param xmldata: an xml.etree.ElementTree - Element() object.
+        """
+        self.xml = etree.Element('metadata')
+        self.xml.append(xmldata)

falcon/lib/python3.10/site-packages/svgwrite/container.py

@@ -0,0 +1,287 @@
+#coding:utf-8
+# Author:  mozman
+# Purpose: svg container classes
+# Created: 15.09.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+"""
+The **container** module provides following structural objects:
+
+* :class:`svgwrite.Group`
+* :class:`svgwrite.SVG`
+* :class:`svgwrite.Defs`
+* :class:`svgwrite.Symbol`
+* :class:`svgwrite.Marker`
+* :class:`svgwrite.Use`
+* :class:`svgwrite.Hyperlink`
+* :class:`svgwrite.Script`
+* :class:`svgwrite.Style`
+
+set/get SVG attributes::
+
+    element['attribute'] = value
+    value = element['attribute']
+
+"""
+from urllib.request import urlopen
+from svgwrite.utils import font_mimetype, base64_data, find_first_url
+from svgwrite.base import BaseElement
+from svgwrite.mixins import ViewBox, Transform, XLink
+from svgwrite.mixins import Presentation, Clipping
+from svgwrite.etree import CDATA
+
+
+class Group(BaseElement, Transform, Presentation):
+    """ The **Group** (SVG **g**) element is a container element for grouping
+    together related graphics elements.
+
+    Grouping constructs, when used in conjunction with the **desc** and **title**
+    elements, provide information about document structure and semantics.
+    Documents that are rich in structure may be rendered graphically, as speech,
+    or as braille, and thus promote accessibility.
+
+    A group of elements, as well as individual objects, can be given a name using
+    the **id** attribute. Named groups are needed for several purposes such as
+    animation and re-usable objects.
+
+    """
+    elementname = 'g'
+
+
+class Defs(Group):
+    """ The **defs** element is a container element for referenced elements. For
+    understandability and accessibility reasons, it is recommended that, whenever
+    possible, referenced elements be defined inside of a **defs**.
+    """
+    elementname = 'defs'
+
+
+class Symbol(BaseElement, ViewBox, Presentation, Clipping):
+    """ The **symbol** element is used to define graphical template objects which
+    can be instantiated by a **use** element. The use of **symbol** elements for
+    graphics that are used multiple times in the same document adds structure and
+    semantics. Documents that are rich in structure may be rendered graphically,
+    as speech, or as braille, and thus promote accessibility.
+    """
+    # ITransform interface is not valid for Symbol -> do not inherit from Group
+    elementname = 'symbol'
+
+
+class Marker(BaseElement, ViewBox, Presentation):
+    """ The **marker** element defines the graphics that is to be used for
+    drawing arrowheads or polymarkers on a given **path**, **line**, **polyline**
+    or **polygon** element.
+
+    Add Marker definitions to a **defs** section, preferred to the **defs** section
+    of the **main drawing**.
+
+    """
+    elementname = 'marker'
+
+    def __init__(self, insert=None, size=None, orient=None, **extra):
+        """
+        :param 2-tuple insert: reference point (**refX**, **refY**)
+        :param 2-tuple size: (**markerWidth**, **markerHeight**)
+        :param orient: ``'auto'`` | `angle`
+        :param extra: additional SVG attributes as keyword-arguments
+        """
+        super(Marker, self).__init__(**extra)
+        if insert is not None:
+            self['refX'] = insert[0]
+            self['refY'] = insert[1]
+        if size is not None:
+            self['markerWidth'] = size[0]
+            self['markerHeight'] = size[1]
+        if orient is not None:
+            self['orient'] = orient
+        if 'id' not in self.attribs:  # an 'id' is necessary
+            self['id'] = self.next_id()
+
+
+FONT_TEMPLATE = """@font-face{{ 
+    font-family: "{name}"; 
+    src: url("{data}"); 
+}}
+"""
+
+
+class SVG(Symbol):
+    """ A SVG document fragment consists of any number of SVG elements contained
+    within an **svg** element.
+
+    An SVG document fragment can range from an empty fragment (i.e., no content
+    inside of the **svg** element), to a very simple SVG document fragment containing
+    a single SVG graphics element such as a **rect**, to a complex, deeply nested
+    collection of container elements and graphics elements.
+    """
+    elementname = 'svg'
+
+    def __init__(self, insert=None, size=None, **extra):
+        """
+        :param 2-tuple insert: insert position (**x**, **y**)
+        :param 2-tuple size: (**width**, **height**)
+        :param extra: additional SVG attributes as keyword-arguments
+        """
+        super(SVG, self).__init__(**extra)
+        if insert is not None:
+            self['x'] = insert[0]
+            self['y'] = insert[1]
+        if size is not None:
+            self['width'] = size[0]
+            self['height'] = size[1]
+
+        self.defs = Defs(factory=self)  # defs container
+        self.add(self.defs)  # add defs as first element
+
+    def embed_stylesheet(self, content):
+        """ Add <style> tag to the defs section.
+
+        :param content: style sheet content as string
+        :return: :class:`~svgwrite.container.Style` object
+        """
+        return self.defs.add(Style(content))
+
+    def embed_font(self, name, filename):
+        """ Embed font as base64 encoded data from font file.
+
+        :param name: font name
+        :param filename: file name of local stored font
+        """
+        data = open(filename, 'rb').read()
+        self._embed_font_data(name, data, font_mimetype(filename))
+
+    def embed_google_web_font(self, name, uri):
+        """ Embed font as base64 encoded data acquired from google fonts.
+
+        :param name: font name
+        :param uri: google fonts request uri like 'http://fonts.googleapis.com/css?family=Indie+Flower'
+        """
+        font_info = urlopen(uri).read()
+        font_url = find_first_url(font_info.decode())
+        if font_url is None:
+            raise ValueError("Got no font data from uri: '{}'".format(uri))
+        else:
+            data = urlopen(font_url).read()
+            self._embed_font_data(name, data, font_mimetype(font_url))
+
+    def _embed_font_data(self, name, data, mimetype):
+        content = FONT_TEMPLATE.format(name=name, data=base64_data(data, mimetype))
+        self.embed_stylesheet(content)
+
+
+class Use(BaseElement, Transform, XLink, Presentation):
+    """ The **use** element references another element and indicates that the graphical
+    contents of that element is included/drawn at that given point in the document.
+
+    Link to objects by href = ``'#object-id'`` or use the object itself as
+    href-argument, if the given element has no **id** attribute it gets an
+    automatic generated id.
+
+    """
+    elementname = 'use'
+
+    def __init__(self, href, insert=None, size=None, **extra):
+        """
+        :param string href: object link (id-string) or an object with an id-attribute
+        :param 2-tuple insert: insert point (**x**, **y**)
+        :param 2-tuple size: (**width**, **height**)
+        :param extra: additional SVG attributes as keyword-arguments
+        """
+        super(Use, self).__init__(**extra)
+        self.set_href(href)
+        if insert is not None:
+            self['x'] = insert[0]
+            self['y'] = insert[1]
+        if size is not None:
+            self['width'] = size[0]
+            self['height'] = size[1]
+
+    def get_xml(self):
+        self.update_id()  # if href is an object - 'id' - attribute may be changed!
+        return super(Use, self).get_xml()
+
+
+class Hyperlink(BaseElement, Transform, Presentation):
+    """ The **a** element indicate links (also known as Hyperlinks or Web links).
+
+    The remote resource (the destination for the link) is defined by a `<URI>`
+    specified by the XLink **xlink:href** attribute. The remote resource may be
+    any Web resource (e.g., an image, a video clip, a sound bite, a program,
+    another SVG document, an HTML document, an element within the current
+    document, an element within a different document, etc.). By activating
+    these links (by clicking with the mouse, through keyboard input, voice
+    commands, etc.), users may visit these resources.
+
+    A **Hyperlink** is defined for each separate rendered element
+    contained within the **Hyperlink** class; add sublements as usual with
+    the `add` method.
+
+    """
+    elementname = 'a'
+
+    def __init__(self, href, target='_blank', **extra):
+        """
+        :param string href: hyperlink to the target resource
+        :param string target: ``'_blank|_replace|_self|_parent|_top|<XML-name>'``
+        :param extra: additional SVG attributes as keyword-arguments
+        """
+        super(Hyperlink, self).__init__(**extra)
+        self['xlink:href'] = href
+        if target is not None:
+            self['target'] = target
+
+
+class Script(BaseElement):
+    """ The **script** element indicate links to a client-side language.  This
+    is normally a  (also known as Hyperlinks or Web links).
+
+    The remote resource (the source of the script) is defined by a `<URI>`
+    specified by the XLink **xlink:href** attribute. The remote resource must
+    be a text-file that contains the script contents.  This script can be used
+    within the SVG file by catching events or adding the mouseover/mousedown/
+    mouseup elements to the markup.
+
+    """
+    elementname = 'script'
+
+    def __init__(self, href=None, content="", **extra):
+        """
+        :param string href: hyperlink to the target resource or *None* if using *content*
+        :param string content: script content
+        :param extra: additional attributes as keyword-arguments
+
+        Use *href* **or** *content*, but not both at the same time.
+
+        """
+        # removed type parameter, default is "application/ecmascript"
+        super(Script, self).__init__(**extra)
+        if href is not None:
+            self['xlink:href'] = href
+        self._content = content
+
+    def get_xml(self):
+        xml = super(Script, self).get_xml()
+        if self._content:
+            xml.append(CDATA(self._content))
+        return xml
+
+    def append(self, content):
+        """ Append content to the existing element-content. """
+        self._content += content
+
+
+class Style(Script):
+    """ The *style* element allows style sheets to be embedded directly within
+    SVG content. SVG's *style* element has the same attributes as the
+    corresponding element in HTML.
+
+    """
+    elementname = 'style'
+
+    def __init__(self, content="", **extra):
+        """
+        :param string content: stylesheet content
+        """
+        super(Style, self).__init__(content=content, **extra)
+        self['type'] = "text/css"
+

falcon/lib/python3.10/site-packages/svgwrite/data/colors.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman --<mozman@gmx.at>
+# Purpose: colornames
+# Created: 06.10.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+
+colornames = frozenset([
+    'aliceblue',
+    'antiquewhite',
+    'aqua',
+    'aquamarine',
+    'azure',
+    'beige',
+    'bisque',
+    'black',
+    'blanchedalmond',
+    'blue',
+    'blueviolet',
+    'brown',
+    'burlywood',
+    'cadetblue',
+    'chartreuse',
+    'chocolate',
+    'coral',
+    'cornflowerblue',
+    'cornsilk',
+    'crimson',
+    'cyan',
+    'darkblue',
+    'darkcyan',
+    'darkgoldenrod',
+    'darkgray',
+    'darkgreen',
+    'darkgrey',
+    'darkkhaki',
+    'darkmagenta',
+    'darkolivegreen',
+    'darkorange',
+    'darkorchid',
+    'darkred',
+    'darksalmon',
+    'darkseagreen',
+    'darkslateblue',
+    'darkslategray',
+    'darkslategrey',
+    'darkturquoise',
+    'darkviolet',
+    'deeppink',
+    'deepskyblue',
+    'dimgray',
+    'dimgrey',
+    'dodgerblue',
+    'firebrick',
+    'floralwhite',
+    'forestgreen',
+    'fuchsia',
+    'gainsboro',
+    'ghostwhite',
+    'gold',
+    'goldenrod',
+    'gray',
+    'green',
+    'greenyellow',
+    'grey',
+    'honeydew',
+    'hotpink',
+    'indianred',
+    'indigo',
+    'ivory',
+    'khaki',
+    'lavender',
+    'lavenderblush',
+    'lawngreen',
+    'lemonchiffon',
+    'lightblue',
+    'lightcoral',
+    'lightcyan',
+    'lightgoldenrodyellow',
+    'lightgray',
+    'lightgreen',
+    'lightgrey',
+    'lightpink',
+    'lightsalmon',
+    'lightseagreen',
+    'lightskyblue',
+    'lightslategray',
+    'lightslategrey',
+    'lightsteelblue',
+    'lightyellow',
+    'lime',
+    'limegreen',
+    'linen',
+    'magenta',
+    'maroon',
+    'mediumaquamarine',
+    'mediumblue',
+    'mediumorchid',
+    'mediumpurple',
+    'mediumseagreen',
+    'mediumslateblue',
+    'mediumspringgreen',
+    'mediumturquoise',
+    'mediumvioletred',
+    'midnightblue',
+    'mintcream',
+    'mistyrose',
+    'moccasin',
+    'navajowhite',
+    'navy',
+    'oldlace',
+    'olive',
+    'olivedrab',
+    'orange',
+    'orangered',
+    'orchid',
+    'palegoldenrod',
+    'palegreen',
+    'paleturquoise',
+    'palevioletred',
+    'papayawhip',
+    'peachpuff',
+    'peru',
+    'pink',
+    'plum',
+    'powderblue',
+    'purple',
+    'red',
+    'rosybrown',
+    'royalblue',
+    'saddlebrown',
+    'salmon',
+    'sandybrown',
+    'seagreen',
+    'seashell',
+    'sienna',
+    'silver',
+    'skyblue',
+    'slateblue',
+    'slategray',
+    'slategrey',
+    'snow',
+    'springgreen',
+    'steelblue',
+    'tan',
+    'teal',
+    'thistle',
+    'tomato',
+    'turquoise',
+    'violet',
+    'wheat',
+    'white',
+    'whitesmoke',
+    'yellow',
+    'yellowgreen',])

falcon/lib/python3.10/site-packages/svgwrite/data/full11.py

@@ -0,0 +1,1405 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman --<mozman@gmx.at>
+# Purpose: full11 data
+# Created: 15.10.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+
+from svgwrite.data.types import SVGAttribute, SVGMultiAttribute
+from svgwrite.data.types import SVGElement
+from svgwrite.data.typechecker import Full11TypeChecker as TypeChecker
+
+empty_list = []
+
+attributes = {
+'accent-height': SVGAttribute('accent-height', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'accumulate': SVGAttribute('accumulate', anim=False,
+    types=empty_list,
+    const=frozenset(['none', 'sum'])),
+'additive': SVGAttribute('additive', anim=False,
+    types=empty_list,
+    const=frozenset(['sum', 'replace'])),
+'alignment-baseline': SVGAttribute('alignment-baseline', anim=True,
+    types=empty_list,
+    const=frozenset(['mathematical', 'before-edge', 'central', 'baseline',
+                     'auto', 'hanging', 'ideographic', 'inherit', 'middle',
+                     'alphabetic', 'text-before-edge', 'text-after-edge',
+                     'after-edge'])),
+'alphabetic': SVGAttribute('alphabetic', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'amplitude': SVGAttribute('amplitude', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'arabic-form': SVGAttribute('arabic-form', anim=False,
+    types=empty_list,
+    const=frozenset(['terminal', 'initial', 'isolated', 'medial'])),
+'ascent': SVGAttribute('ascent', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'attributeName': SVGAttribute('attributeName', anim=False,
+    types=frozenset(['name']),
+    const=empty_list),
+'attributeType': SVGAttribute('attributeType', anim=False,
+    types=empty_list,
+    const=frozenset(['XML', 'auto', 'CSS'])),
+'azimuth': SVGAttribute('azimuth', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'baseFrequency': SVGAttribute('baseFrequency', anim=True,
+    types=frozenset(['number-optional-number']),
+    const=empty_list),
+'baseline-shift': SVGAttribute('baseline-shift', anim=True,
+    types=frozenset(['percentage', 'length']),
+    const=frozenset(['super', 'baseline', 'inherit', 'sub'])),
+'baseProfile': SVGAttribute('baseProfile', anim=False,
+    types=empty_list,
+    const=frozenset(['full', 'tiny', 'basic', 'none'])),
+'bbox': SVGAttribute('bbox', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'begin': SVGAttribute('begin', anim=True,
+    types=frozenset(['timing-value-list']),
+    const=frozenset(['indefinite'])),
+'bias': SVGAttribute('bias', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'by': SVGAttribute('by', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'calcMode': SVGAttribute('calcMode', anim=False,
+    types=empty_list,
+    const=frozenset(['discrete', 'linear', 'paced', 'spline'])),
+'cap-height': SVGAttribute('cap-height', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'class': SVGAttribute('class', anim=True,
+    types=frozenset(['list-of-name']),
+    const=empty_list),
+'clip': SVGAttribute('clip', anim=True,
+    types=frozenset(['shape']),
+    const=frozenset(['auto', 'inherit'])),
+'clip-path': SVGAttribute('clip-path', anim=True,
+    types=frozenset(['IRI']),
+    const=frozenset(['none', 'inherit'])),
+'clip-rule': SVGAttribute('clip-rule', anim=True,
+    types=empty_list,
+    const=frozenset(['nonzero', 'evenodd', 'inherit'])),
+'clipPathUnits': SVGAttribute('clipPathUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'color': SVGAttribute('color', anim=True,
+    types=frozenset(['color']),
+    const=frozenset(['inherit'])),
+'color-interpolation': SVGAttribute('color-interpolation', anim=True,
+    types=empty_list,
+    const=frozenset(['auto', 'sRGB', 'inherit', 'linearRGB'])),
+'color-interpolation-filters': SVGAttribute('color-interpolation-filters', anim=True,
+    types=empty_list,
+    const=frozenset(['auto', 'sRGB', 'inherit', 'linearRGB'])),
+'color-profile': SVGAttribute('color-profile', anim=True,
+    types=frozenset(['FuncIRI', 'name']),
+    const=frozenset(['auto', 'sRGB', 'inherit'])),
+'color-rendering': SVGAttribute('color-rendering', anim=True,
+    types=empty_list,
+    const=frozenset(['auto', 'optimizeQuality', 'optimizeSpeed', 'inherit'])),
+'contentScriptType': SVGAttribute('contentScriptType', anim=True,
+    types=frozenset(['string']),
+    const=empty_list),
+'contentStyleType': SVGAttribute('contentStyleType', anim=True,
+    types=frozenset(['string']),
+    const=empty_list),
+'cursor': SVGAttribute('cursor', anim=True,
+    types=frozenset(['list-of-FuncIRI']),
+    const=frozenset(['sw-resize', 'n-resize', 'help', 'text', 'move', 'auto',
+                     'w-resize', 'pointer', 'wait', 's-resize', 'e-resize',
+                     'default', 'inherit', 'nw-resize', 'ne-resize',
+                     'crosshair', 'se-resize'])),
+'cx': SVGAttribute('cx', anim=True,
+    types=frozenset(['coordinate']),
+    const=empty_list),
+'cy': SVGAttribute('cy', anim=True,
+    types=frozenset(['coordinate']),
+    const=empty_list),
+'d': SVGMultiAttribute({
+    '* path': SVGAttribute( # '*' means default attribute
+        'd', anim=True,
+        types=frozenset(['path-data']),
+        const=empty_list
+        ),
+    'glyph missing-glyph': SVGAttribute(
+        'd', anim=False,
+        types=frozenset(['path-data']),
+        const=empty_list
+        ),
+    }),
+'descent': SVGAttribute('descent', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'diffuseConstant': SVGAttribute('diffuseConstant', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'direction': SVGAttribute('direction', anim=False,
+    types=empty_list,
+    const=frozenset(['ltr', 'inherit', 'rtl'])),
+'display': SVGAttribute('display', anim=True,
+    types=empty_list,
+    const=frozenset(['inline-table', 'table-header-group', 'table-footer-group',
+                     'none', 'table-row', 'table-caption', 'table-column',
+                     'marker', 'table', 'compact', 'table-row-group', 'run-in',
+                     'inherit', 'list-item', 'table-cell', 'inline',
+                     'block', 'table-column-group'])),
+'divisor': SVGAttribute('divisor', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'dominant-baseline': SVGAttribute('dominant-baseline', anim=True,
+    types=empty_list,
+    const=frozenset(['mathematical', 'use-script', 'ideographic', 'central',
+                     'reset-size', 'auto', 'hanging', 'inherit', 'middle',
+                     'alphabetic', 'text-before-edge', 'text-after-edge',
+                     'no-change'])),
+'dur': SVGAttribute('dur', anim=True,
+    types=frozenset(['time']),
+    const=frozenset(['media', 'indefinite'])),
+'dx': SVGMultiAttribute({
+    '* altGlyph text tref tspan': SVGAttribute(
+        'dx', anim=True,
+        types=frozenset(['list-of-length']),
+        const=empty_list),
+    'feOffset': SVGAttribute(
+        'dx', anim=True,
+        types=frozenset(['number']),
+        const=empty_list),
+    'glyphRef': SVGAttribute(
+        'dx', anim=False,
+        types=frozenset(['number']),
+        const=empty_list),
+    }),
+'dy': SVGMultiAttribute({
+    '* altGlyph text tref tspan': SVGAttribute(
+        'dy', anim=True,
+        types=frozenset(['list-of-length']),
+        const=empty_list),
+    'feOffset': SVGAttribute(
+        'dy', anim=True,
+        types=frozenset(['number']),
+        const=empty_list),
+    'glyphRef': SVGAttribute(
+        'dy', anim=False,
+        types=frozenset(['number']),
+        const=empty_list),
+    }),
+'edgeMode': SVGAttribute('edgeMode', anim=True,
+    types=empty_list,
+    const=frozenset(['wrap', 'duplicate', 'none'])),
+'elevation': SVGAttribute('elevation', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'enable-background': SVGAttribute('enable-background', anim=True,
+    types=frozenset(['string']),
+    const=frozenset(['accummulate', 'new', 'inherit'])),
+'end': SVGAttribute('end', anim=False,
+    types=frozenset(['timing-value-list']),
+    const=frozenset(['indefinite'])),
+'exponent': SVGAttribute('exponent', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'externalResourcesRequired': SVGAttribute('externalResourcesRequired', anim=True,
+    types=empty_list,
+    const=frozenset(['true', 'false'])),
+'fill': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'fill', anim=True,
+        types=frozenset(['paint']),
+        const=empty_list),
+    'set animateMotion animate animateColor animateTransform': SVGAttribute(
+        'fill', anim=False,
+        types=empty_list,
+        const=frozenset(['freeze', 'remove']))
+    }),
+'fill-opacity': SVGAttribute('fill-opacity', anim=True,
+    types=frozenset(['number']),
+    const=frozenset(['inherit'])),
+'fill-rule': SVGAttribute('fill-rule', anim=True,
+    types=empty_list,
+    const=frozenset(['nonzero', 'evenodd', 'inherit'])),
+'filter': SVGAttribute('filter', anim=True,
+    types=frozenset(['FuncIRI']),
+    const=frozenset(['none', 'inherit'])),
+'filterRes': SVGAttribute('filterRes', anim=True,
+    types=frozenset(['number-optional-number']),
+    const=empty_list),
+'filterUnits': SVGAttribute('filterUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'flood-color': SVGAttribute('flood-color', anim=True,
+    types=frozenset(['color', 'icccolor']),
+    const=frozenset(['currentColor', 'inherit'])),
+'flood-opacity': SVGAttribute('flood-opacity', anim=True,
+    types=frozenset(['number']),
+    const=frozenset(['inherit'])),
+'font': SVGAttribute('font', anim=True,
+    types=frozenset(['string']),
+    const=empty_list),
+'font-family': SVGAttribute('font-family', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'font-size': SVGAttribute('font-size', anim=False,
+    types=frozenset(['length']),
+    const=frozenset(['inherit'])),
+'font-size-adjust': SVGAttribute('font-size-adjust', anim=True,
+    types=frozenset(['number']),
+    const=frozenset(['none', 'inherit'])),
+'font-stretch': SVGAttribute('font-stretch', anim=False,
+    types=empty_list,
+    const=frozenset(['condensed', 'normal', 'ultra-condensed', 'expanded',
+                     'narrower', 'inherit', 'semi-condensed', 'extra-condensed',
+                     'ultra-expanded', 'wider', 'semi-expanded', 'extra-expanded'])),
+'font-style': SVGAttribute('font-style', anim=False,
+    types=empty_list,
+    const=frozenset(['oblique', 'inherit', 'italic', 'normal'])),
+'font-variant': SVGAttribute('font-variant', anim=False,
+    types=empty_list,
+    const=frozenset(['small-caps', 'inherit', 'normal'])),
+'font-weight': SVGAttribute('font-weight', anim=False,
+    types=empty_list,
+    const=frozenset(['200', '900', 'bold', 'bolder', 'normal', '300', '700',
+                     'inherit', 'lighter', '400', '100', '800', '500', '600'])),
+'format': SVGAttribute('format', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'from': SVGAttribute('from', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'fx': SVGAttribute('fx', anim=True,
+    types=frozenset(['coordinate']),
+    const=empty_list),
+'fy': SVGAttribute('fy', anim=True,
+    types=frozenset(['coordinate']),
+    const=empty_list),
+'g1': SVGAttribute('g1', anim=False,
+    types=frozenset(['list-of-name']),
+    const=empty_list),
+'g2': SVGAttribute('g2', anim=False,
+    types=frozenset(['list-of-name']),
+    const=empty_list),
+'glyph-name': SVGAttribute('glyph-name', anim=False,
+    types=frozenset(['list-of-name']),
+    const=empty_list),
+'glyph-orientation-horizontal': SVGAttribute('glyph-orientation-horizontal', anim=True,
+    types=frozenset(['angle']),
+    const=frozenset(['inherit'])),
+'glyph-orientation-vertical': SVGAttribute('glyph-orientation-vertical', anim=True,
+    types=frozenset(['angle']),
+    const=frozenset(['auto', 'inherit'])),
+'glyphRef': SVGAttribute('glyphRef', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'gradientTransform': SVGAttribute('gradientTransform', anim=True,
+    types=frozenset(['transform-list']),
+    const=empty_list),
+'gradientUnits': SVGAttribute('gradientUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'hanging': SVGAttribute('hanging', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'height': SVGAttribute('height', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'horiz-adv-x': SVGAttribute('horiz-adv-x', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'horiz-origin-x': SVGAttribute('horiz-origin-x', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'horiz-origin-y': SVGAttribute('horiz-origin-y', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'id': SVGAttribute('id', anim=False,
+    types=frozenset(['name']),
+    const=empty_list),
+'ideographic': SVGAttribute('ideographic', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'image-rendering': SVGAttribute('image-rendering', anim=True,
+    types=empty_list,
+    const=frozenset(['auto', 'optimizeQuality', 'optimizeSpeed', 'inherit'])),
+'in': SVGAttribute('in', anim=True,
+    types=frozenset(['name']),
+    const=frozenset(['SourceAlpha', 'SourceGraphic', 'BackgroundAlpha',
+                     'BackgroundImage', 'StrokePaint', 'FillPaint'])),
+'in2': SVGAttribute('in2', anim=True,
+    types=frozenset(['name']),
+    const=frozenset(['SourceAlpha', 'SourceGraphic', 'BackgroundAlpha',
+                     'BackgroundImage', 'StrokePaint', 'FillPaint'])),
+'intercept': SVGAttribute('intercept', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'k': SVGAttribute('k', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'k1': SVGAttribute('k1', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'k2': SVGAttribute('k2', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'k3': SVGAttribute('k3', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'k4': SVGAttribute('k4', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'kernelMatrix': SVGAttribute('kernelMatrix', anim=True,
+    types=frozenset(['list-of-number']),
+    const=empty_list),
+'kernelUnitLength': SVGAttribute('kernelUnitLength', anim=True,
+    types=frozenset(['number-optional-number']),
+    const=empty_list),
+'kerning': SVGAttribute('kerning', anim=True,
+    types=frozenset(['length']),
+    const=frozenset(['auto', 'inherit'])),
+'keyPoints': SVGAttribute('keyPoints', anim=False,
+    types=frozenset(['semicolon-list']),
+    const=empty_list),
+'keySplines': SVGAttribute('keySplines', anim=False,
+    types=frozenset(['semicolon-list']),
+    const=empty_list),
+'keyTimes': SVGAttribute('keyTimes', anim=False,
+    types=frozenset(['semicolon-list']),
+    const=empty_list),
+'lang': SVGAttribute('lang', anim=False,
+    types=frozenset(['name']),
+    const=empty_list),
+'lengthAdjust': SVGAttribute('lengthAdjust', anim=True,
+    types=empty_list,
+    const=frozenset(['spacingAndGlyphs', 'spacing'])),
+'letter-spacing': SVGAttribute('letter-spacing', anim=True,
+    types=frozenset(['length']),
+    const=frozenset(['inherit', 'normal'])),
+'lighting-color': SVGAttribute('lighting-color', anim=True,
+    types=frozenset(['color', 'icccolor']),
+    const=frozenset(['currentColor', 'inherit'])),
+'limitingConeAngle': SVGAttribute('limitingConeAngle', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'local': SVGAttribute('local', anim=True,
+    types=frozenset(['string']),
+    const=empty_list),
+'marker': SVGAttribute('marker', anim=True,
+    types=frozenset(['FuncIRI']),
+    const=frozenset(['none', 'inherit'])),
+'marker-end': SVGAttribute('marker-end', anim=True,
+    types=frozenset(['FuncIRI']),
+    const=frozenset(['none', 'inherit'])),
+'marker-mid': SVGAttribute('marker-mid', anim=True,
+    types=frozenset(['FuncIRI']),
+    const=frozenset(['none', 'inherit'])),
+'marker-start': SVGAttribute('marker-start', anim=True,
+    types=frozenset(['FuncIRI']),
+    const=frozenset(['none', 'inherit'])),
+'markerHeight': SVGAttribute('markerHeight', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'markerUnits': SVGAttribute('markerUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'strokeWidth'])),
+'markerWidth': SVGAttribute('markerWidth', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'mask': SVGAttribute('mask', anim=True,
+    types=frozenset(['FuncIRI']),
+    const=frozenset(['none', 'inherit'])),
+'maskContentUnits': SVGAttribute('maskContentUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'maskUnits': SVGAttribute('maskUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'mathematical': SVGAttribute('mathematical', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'max': SVGAttribute('max', anim=False,
+    types=frozenset(['time']),
+    const=frozenset(['media'])),
+'media': SVGAttribute('media', anim=False,
+    types=empty_list,
+    const=frozenset(['all', 'aureal', 'braille', 'embossed', 'handheld', 'print',
+                     'projection', 'screen', 'tty', 'tv'])),
+'method': SVGAttribute('method', anim=True,
+    types=empty_list,
+    const=frozenset(['stretch', 'align'])),
+'min': SVGAttribute('min', anim=False,
+    types=frozenset(['time']),
+    const=frozenset(['media'])),
+'mode': SVGAttribute('mode', anim=True,
+    types=empty_list,
+    const=frozenset(['multiply', 'screen', 'darken', 'lighten', 'normal'])),
+'name': SVGMultiAttribute({
+    '* font-face-name': SVGAttribute(
+        'name', anim=False,
+        types=frozenset(['anything']),
+        const=empty_list),
+    'color-profile': SVGAttribute(
+        'name', anim=False,
+        types=frozenset(['name']),
+        const=empty_list),
+    }),
+'numOctaves': SVGAttribute('numOctaves', anim=True,
+    types=frozenset(['integer']),
+    const=empty_list),
+'offset': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'offset', anim=True,
+        types=frozenset(['number']),
+        const=empty_list),
+    'stop': SVGAttribute(
+        'offset', anim=True,
+        types=frozenset(['number', 'percentage']),
+        const=empty_list),
+    }),
+'onabort': SVGAttribute('onabort', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onactivate': SVGAttribute('onactivate', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onbegin': SVGAttribute('onbegin', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onclick': SVGAttribute('onclick', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onend': SVGAttribute('onend', anim=True,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onerror': SVGAttribute('onerror', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onfocusin': SVGAttribute('onfocusin', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onfocusout': SVGAttribute('onfocusout', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onload': SVGAttribute('onload', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onmousedown': SVGAttribute('onmousedown', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onmousemove': SVGAttribute('onmousemove', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onmouseout': SVGAttribute('onmouseout', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onmouseover': SVGAttribute('onmouseover', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onmouseup': SVGAttribute('onmouseup', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onrepeat': SVGAttribute('onrepeat', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onresize': SVGAttribute('onresize', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onscroll': SVGAttribute('onscroll', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onunload': SVGAttribute('onunload', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'onzoom': SVGAttribute('onzoom', anim=False,
+    types=frozenset(['anything']),
+    const=empty_list),
+'opacity': SVGAttribute('opacity', anim=True,
+    types=frozenset(['number']),
+    const=frozenset(['inherit'])),
+'operator': SVGMultiAttribute({
+    '* feComposite': SVGAttribute(
+        'operator', anim=True,
+        types=empty_list,
+        const=frozenset(['xor', 'in', 'over', 'atop', 'arithmetic', 'out'])),
+    'feMorphology': SVGAttribute(
+        'operator', anim=True,
+        types=empty_list,
+        const=frozenset(['erode', 'dilate'])),
+    }),
+'order': SVGAttribute('order', anim=True,
+    types=frozenset(['number-optional-number']),
+    const=empty_list),
+'orient': SVGAttribute('orient', anim=True,
+    types=frozenset(['angle']),
+    const=frozenset(['auto'])),
+'orientation': SVGAttribute('orientation', anim=False,
+    types=empty_list,
+    const=frozenset(['h', 'v'])),
+'origin': SVGAttribute('origin', anim=False,
+    types=empty_list,
+    const=frozenset(['default'])),
+'overflow': SVGAttribute('overflow', anim=True,
+    types=empty_list,
+    const=frozenset(['visible', 'hidden', 'scroll', 'inherit', 'auto'])),
+'overline-position': SVGAttribute('overline-position', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'overline-thickness': SVGAttribute('overline-thickness', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'panose-1': SVGAttribute('panose-1', anim=False,
+    types=frozenset(['list-of-integer']),
+    const=empty_list),
+'path': SVGAttribute('path', anim=False,
+    types=frozenset(['path-data']),
+    const=empty_list),
+'pathLength': SVGAttribute('pathLength', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'patternContentUnits': SVGAttribute('patternContentUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'patternTransform': SVGAttribute('patternTransform', anim=True,
+    types=frozenset(['transform-list']),
+    const=empty_list),
+'patternUnits': SVGAttribute('patternUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'pointer-events': SVGAttribute('pointer-events', anim=True,
+    types=empty_list,
+    const=frozenset(['all', 'visibleStroke', 'painted', 'none', 'visibleFill',
+                     'visible', 'stroke', 'inherit', 'visiblePainted', 'fill'])),
+'points': SVGAttribute('points', anim=True,
+    types=frozenset(['list-of-points']),
+    const=empty_list),
+'pointsAtX': SVGAttribute('pointsAtX', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'pointsAtY': SVGAttribute('pointsAtY', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'pointsAtZ': SVGAttribute('pointsAtZ', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'preserveAlpha': SVGAttribute('preserveAlpha', anim=True,
+    types=empty_list,
+    const=frozenset(['true', 'false'])),
+'preserveAspectRatio': SVGAttribute('preserveAspectRatio', anim=True,
+    types=frozenset('string'),
+    const=empty_list),
+'primitiveUnits': SVGAttribute('primitiveUnits', anim=True,
+    types=empty_list,
+    const=frozenset(['userSpaceOnUse', 'objectBoundingBox'])),
+'r': SVGAttribute('r', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'radius': SVGAttribute('radius', anim=True,
+    types=frozenset(['number-optional-number']),
+    const=empty_list),
+'refX': SVGAttribute('refX', anim=True,
+    types=frozenset(['coordinate']),
+    const=empty_list),
+'refY': SVGAttribute('refY', anim=True,
+    types=frozenset(['coordinate']),
+    const=empty_list),
+'rendering-intent': SVGAttribute('rendering-intent', anim=False,
+    types=empty_list,
+    const=frozenset(['auto', 'saturation', 'perceptual', 'relative-colorimetric',
+                     'absolute-colorimetric'])),
+'repeatCount': SVGAttribute('repeatCount', anim=False,
+    types=frozenset(['number']),
+    const=frozenset(['indefinite'])),
+'repeatDur': SVGAttribute('repeatDur', anim=False,
+    types=frozenset(['time']),
+    const=frozenset(['indefinite'])),
+'requiredExtensions': SVGAttribute('requiredExtensions', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'requiredFeatures': SVGAttribute('requiredFeatures', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'restart': SVGAttribute('restart', anim=False,
+    types=empty_list,
+    const=frozenset(['always', 'never', 'whenNotActive'])),
+'result': SVGAttribute('result', anim=True,
+    types=frozenset(['list-of-name']),
+    const=empty_list),
+'rotate': SVGMultiAttribute({
+    '* altGlyph text tref tspan': SVGAttribute(
+        'rotate', anim=True,
+        types=frozenset(['list-of-number']),
+        const=empty_list),
+    'animateMotion': SVGAttribute(
+        'rotate', anim=False,
+        types=frozenset(['number']),
+        const=frozenset(['auto', 'auto-reverse'])),
+    }),
+'rx': SVGAttribute('rx', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'ry': SVGAttribute('ry', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'scale': SVGAttribute('scale', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'seed': SVGAttribute('seed', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'shape-rendering': SVGAttribute('shape-rendering', anim=True,
+    types=empty_list,
+    const=frozenset(['auto', 'optimizeSpeed', 'inherit', 'geometricPrecision',
+                     'crispEdges'])),
+'slope': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'slope', anim=True,
+        types=frozenset(['number']),
+        const=empty_list),
+    'font-face': SVGAttribute(
+        'slope', anim=False,
+        types=frozenset(['number']),
+        const=empty_list),
+    }),
+'spacing': SVGAttribute('spacing', anim=True,
+    types=empty_list,
+    const=frozenset(['auto', 'exact'])),
+'specularConstant': SVGAttribute('specularConstant', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'specularExponent': SVGAttribute('specularExponent', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'spreadMethod': SVGAttribute('spreadMethod', anim=True,
+    types=empty_list,
+    const=frozenset(['reflect', 'repeat', 'pad'])),
+'startOffset': SVGAttribute('startOffset', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'stdDeviation': SVGAttribute('stdDeviation', anim=True,
+    types=frozenset(['number-optional-number']),
+    const=empty_list),
+'stemh': SVGAttribute('stemh', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'stemv': SVGAttribute('stemv', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'stitchTiles': SVGAttribute('stitchTiles', anim=True,
+    types=empty_list,
+    const=frozenset(['noStitch', 'stitch'])),
+'stop-color': SVGAttribute('stop-color', anim=True,
+    types=frozenset(['color', 'icccolor']),
+    const=frozenset(['currentColor', 'inherit'])),
+'stop-opacity': SVGAttribute('stop-opacity', anim=True,
+    types=frozenset(['number']),
+    const=frozenset(['inherit'])),
+'strikethrough-position': SVGAttribute('strikethrough-position', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'strikethrough-thickness': SVGAttribute('strikethrough-thickness', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'string': SVGAttribute('string', anim=False,
+    types=frozenset('anything'),
+    const=empty_list),
+'stroke': SVGAttribute('stroke', anim=True,
+    types=frozenset(['paint']),
+    const=empty_list),
+'stroke-dasharray': SVGAttribute('stroke-dasharray', anim=True,
+    types=frozenset(['list-of-length']),
+    const=frozenset(['none', 'inherit'])),
+'stroke-dashoffset': SVGAttribute('stroke-dashoffset', anim=True,
+    types=frozenset(['length']),
+    const=frozenset(['inherit'])),
+'stroke-linecap': SVGAttribute('stroke-linecap', anim=True,
+    types=empty_list,
+    const=frozenset(['square', 'round', 'inherit', 'butt'])),
+'stroke-linejoin': SVGAttribute('stroke-linejoin', anim=True,
+    types=empty_list,
+    const=frozenset(['bevel', 'miter', 'round', 'inherit'])),
+'stroke-miterlimit': SVGAttribute('stroke-miterlimit', anim=True,
+    types=frozenset(['number']),
+    const=frozenset(['inherit'])),
+'stroke-opacity': SVGAttribute('stroke-opacity', anim=True,
+    types=frozenset(['number']),
+    const=frozenset(['inherit'])),
+'stroke-width': SVGAttribute('stroke-width', anim=True,
+    types=frozenset(['length']),
+    const=frozenset(['inherit'])),
+'style': SVGAttribute('style', anim=False,
+    types=frozenset('anything'),
+    const=empty_list),
+'surfaceScale': SVGAttribute('surfaceScale', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'systemLanguage': SVGAttribute('systemLanguage', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'tableValues': SVGAttribute('tableValues', anim=True,
+    types=frozenset(['list-of-number']),
+    const=empty_list),
+'target': SVGAttribute('target', anim=True,
+    types=frozenset(['XML-Name']),
+    const=frozenset(['_replace', '_self', '_parent', '_top', '_blank'])),
+'targetX': SVGAttribute('targetX', anim=True,
+    types=frozenset(['integer']),
+    const=empty_list),
+'targetY': SVGAttribute('targetY', anim=True,
+    types=frozenset(['integer']),
+    const=empty_list),
+'text-anchor': SVGAttribute('text-anchor', anim=True,
+    types=empty_list,
+    const=frozenset(['start', 'end', 'inherit', 'middle'])),
+'text-decoration': SVGAttribute('text-decoration', anim=True,
+    types=frozenset(['list-of-text-decoration-style']),
+    const=frozenset(['', 'none', 'inherit'])),
+'text-rendering': SVGAttribute('text-rendering', anim=True,
+    types=empty_list,
+    const=frozenset(['auto', 'optimizeSpeed', 'optimizeLegibility',
+                     'geometricPrecision', 'inherit'])),
+'textLength': SVGAttribute('textLength', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'title': SVGAttribute('title', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'to': SVGAttribute('to', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'transform': SVGAttribute('transform', anim=True,
+    types=frozenset(['transform-list']),
+    const=empty_list),
+'type': SVGMultiAttribute({
+    '* feColorMatrix': SVGAttribute(
+        'type', anim=True,
+        types=empty_list,
+        const=frozenset(['matrix', 'saturate', 'hueRotate', 'luminanceToAlpha'])),
+    'feTurbulence': SVGAttribute(
+        'type', anim=True,
+        types=empty_list,
+        const=frozenset(['fractalNoise', 'turbulence'])),
+    'feFuncR feFuncG feFuncB feFuncA': SVGAttribute(
+        'type', anim=True,
+        types=empty_list,
+        const=frozenset(['identity', 'table', 'discrete', 'linear', 'gamma'])),
+    'script style': SVGAttribute(
+        'type', anim=False,
+        types=frozenset(['content-type']),
+        const=empty_list),
+    'animateTransform': SVGAttribute(
+        'type', anim=False,
+        types=empty_list,
+        const=frozenset(['translate', 'scale', 'rotate', 'skewX', 'skewY'])),
+    }),
+'u1': SVGAttribute('u1', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'u2': SVGAttribute('u2', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'underline-position': SVGAttribute('underline-position', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'underline-thickness': SVGAttribute('underline-thickness', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'unicode': SVGAttribute('unicode', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'unicode-bidi': SVGAttribute('unicode-bidi', anim=False,
+    types=empty_list,
+    const=frozenset(['embed', 'inherit', 'bidi-override', 'normal'])),
+'unicode-range': SVGAttribute('unicode-range', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'units-per-em': SVGAttribute('units-per-em', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'v-alphabetic': SVGAttribute('v-alphabetic', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'v-hanging': SVGAttribute('v-hanging', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'v-ideographic': SVGAttribute('v-ideographic', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'v-mathematical': SVGAttribute('v-mathematical', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'values': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'values', anim=False,
+        types=frozenset(['semicolon-list']),
+        const=empty_list),
+    'feColorMatrix': SVGAttribute(
+        'values', anim=True,
+        types=frozenset(['list-of-number']),
+        const=empty_list),
+    }),
+'version': SVGAttribute('version', anim=False,
+    types=empty_list,
+    const=frozenset(['1.1', '1.2'])),
+'vert-adv-y': SVGAttribute('vert-adv-y', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'vert-origin-x': SVGAttribute('vert-origin-x', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'vert-origin-y': SVGAttribute('vert-origin-y', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'viewBox': SVGAttribute('viewBox', anim=True,
+    types=frozenset(['four-numbers']),
+    const=empty_list),
+'viewTarget': SVGAttribute('viewTarget', anim=False,
+    types=frozenset(['list-of-XML-Name']),
+    const=empty_list),
+'visibility': SVGAttribute('visibility', anim=True,
+    types=empty_list,
+    const=frozenset(['visible', 'hidden', 'collapse', 'inherit'])),
+'width': SVGAttribute('width', anim=True,
+    types=frozenset(['length']),
+    const=empty_list),
+'widths': SVGAttribute('widths', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'word-spacing': SVGAttribute('word-spacing', anim=True,
+    types=frozenset(['length']),
+    const=frozenset(['inherit', 'normal'])),
+'writing-mode': SVGAttribute('writing-mode', anim=False,
+    types=empty_list,
+    const=frozenset(['rl-tb', 'lr', 'rl', 'tb-rl', 'lr-tb', 'inherit', 'tb'])),
+'x': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'x', anim=True,
+        types=frozenset(['coordinate']),
+        const=empty_list),
+    'altGlyph text tref tspan': SVGAttribute(
+        'x', anim=True,
+        types=frozenset(['list-of-coordinate']),
+        const=empty_list),
+    'fePointLight feSpotLight glyphRef': SVGAttribute(
+        'x', anim=True,
+        types=frozenset(['number']),
+        const=empty_list),
+    }),
+'x-height': SVGAttribute('x-height', anim=False,
+    types=frozenset(['number']),
+    const=empty_list),
+'x1': SVGAttribute('x1', anim=True,
+    types=frozenset(['list-of-coordinate']),
+    const=empty_list),
+'x2': SVGAttribute('x2', anim=True,
+    types=frozenset(['list-of-coordinate']),
+    const=empty_list),
+'xChannelSelector': SVGAttribute('xChannelSelector', anim=True,
+    types=empty_list,
+    const=frozenset(['A', 'B', 'R', 'G'])),
+'xlink:actuate': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'xlink:actuate', anim=False,
+        types=empty_list,
+        const=frozenset(['onLoad'])),
+    'a': SVGAttribute(
+        'xlink:actuate', anim=False,
+        types=empty_list,
+        const=frozenset(['onRequest'])),
+    }),
+'xlink:arcrole': SVGAttribute('xlink:arcrole', anim=False,
+    types=frozenset(['IRI']),
+    const=empty_list),
+'xlink:href': SVGAttribute('xlink:href', anim=False,
+    types=frozenset(['IRI']),
+    const=empty_list),
+'xlink:role': SVGAttribute('xlink:role', anim=False,
+    types=frozenset(['IRI']),
+    const=empty_list),
+'xlink:show': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'xlink:show', anim=False,
+        types=empty_list,
+        const=frozenset(['other', 'new', 'replace', 'none', 'embed'])),
+    'a': SVGAttribute(
+        'xlink:show', anim=False,
+        types=empty_list,
+        const=frozenset(['new', 'replace'])),
+    }),
+'xlink:title': SVGAttribute('xlink:title', anim=False,
+    types=frozenset(['string']),
+    const=empty_list),
+'xlink:type': SVGAttribute('xlink:type', anim=False,
+    types=empty_list,
+    const=frozenset(['simple'])),
+'xmlns': SVGAttribute('xmlns', anim=False,
+    types=frozenset(['IRI']),
+    const=empty_list),
+'xmlns:xlink': SVGAttribute('xmlns:xlink', anim=False,
+    types=frozenset(['IRI']),
+    const=empty_list),
+'xmlns:ev': SVGAttribute('xmlns:ev', anim=False,
+    types=frozenset(['IRI']),
+    const=empty_list),
+'xml:base': SVGAttribute('xml:base', anim=False,
+    types=frozenset(['IRI']),
+    const=empty_list),
+'xml:lang': SVGAttribute('xml:lang', anim=False,
+    types=frozenset(['name']),
+    const=empty_list),
+'xml:space': SVGAttribute('xml:space', anim=False,
+    types=empty_list,
+    const=frozenset(['default', 'preserve'])),
+'y': SVGMultiAttribute({
+    '*': SVGAttribute(
+        'y', anim=True,
+        types=frozenset(['coordinate']),
+        const=empty_list),
+    'altGlyph text tref tspan': SVGAttribute(
+        'y', anim=True,
+        types=frozenset(['list-of-coordinate']),
+        const=empty_list),
+    'fePointLight feSpotLight glyphRef': SVGAttribute(
+        'y', anim=True,
+        types=frozenset(['number']),
+        const=empty_list),
+    }),
+'y1': SVGAttribute('y1', anim=True,
+    types=frozenset(['list-of-coordinate']),
+    const=empty_list),
+'y2': SVGAttribute('y2', anim=True,
+    types=frozenset(['list-of-coordinate']),
+    const=empty_list),
+'yChannelSelector': SVGAttribute('yChannelSelector', anim=True,
+    types=empty_list,
+    const=frozenset(['A', 'B', 'R', 'G'])),
+'z': SVGAttribute('z', anim=True,
+    types=frozenset(['number']),
+    const=empty_list),
+'zoomAndPan': SVGAttribute('zoomAndPan', anim=False,
+    types=empty_list,
+    const=frozenset(['disable', 'magnify'])),
+}
+
+presentation_attributes = frozenset([ "alignment-baseline", "baseline-shift",
+    "clip", "clip-path", "clip-rule", "color", "color-interpolation",
+    "color-interpolation-filters", "color-profile", "color-rendering", "cursor",
+    "direction", "display", "dominant-baseline", "enable-background",
+    "fill", "fill-opacity", "fill-rule", "filter", "flood-color",
+    "flood-opacity", "font-family", "font-size", "font-size-adjust",
+    "font-stretch", "font-style", "font-variant", "font-weight",
+    "glyph-orientation-horizontal", "glyph-orientation-vertical",
+    "image-rendering", "kerning", "letter-spacing", "lighting-color", "marker",
+    "marker-end", "marker-mid", "marker-start", "mask", "opacity",
+    "overflow", "pointer-events", "shape-rendering", "stop-color",
+    "stop-opacity", "stroke", "stroke-dasharray", "stroke-dashoffset",
+    "stroke-linecap", "stroke-linejoin", "stroke-miterlimit",
+    "stroke-opacity", "stroke-width", "text-anchor", "text-decoration",
+    "text-rendering", "unicode-bidi", "visibility", "word-spacing",
+    "writing-mode"])
+
+elements = {
+    'a': SVGElement('a',
+    attributes=frozenset(['xlink:title', 'xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'xlink:href', 'systemLanguage', 'onmouseover', 'xlink:type', 'externalResourcesRequired', 'id', 'xlink:actuate', 'onload', 'style', 'xlink:show', 'target', 'onactivate', 'onmousedown', 'transform', 'class', 'xlink:role', 'requiredFeatures', 'xml:lang', 'onmousemove', 'xmlns:xlink', 'onclick', 'xlink:arcrole', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'altGlyph': SVGElement('altGlyph',
+    attributes=frozenset(['requiredExtensions', 'onfocusout', 'xml:space', 'xlink:href', 'id', 'onload', 'style', 'onmousedown', 'onmousemove', 'onclick', 'xlink:arcrole', 'onfocusin', 'xml:base', 'onmouseup', 'onmouseout', 'format', 'xlink:title', 'systemLanguage', 'onmouseover', 'dx', 'dy', 'xlink:type', 'externalResourcesRequired', 'class', 'xlink:actuate', 'xlink:show', 'onactivate', 'glyphRef', 'xlink:role', 'requiredFeatures', 'xml:lang', 'y', 'x', 'rotate']),
+    properties=presentation_attributes,
+    children=empty_list),
+
+    'altGlyphDef': SVGElement('altGlyphDef',
+    attributes=frozenset(['xml:space', 'xml:lang', 'xml:base', 'id']),
+    properties=empty_list,
+    children=frozenset(['*'])),
+
+    'altGlyphItem': SVGElement('altGlyphItem',
+    attributes=frozenset(['xml:space', 'xml:lang', 'xml:base', 'id']),
+    properties=empty_list,
+    children=frozenset(['*'])),
+
+    'animate': SVGElement('animate',
+    attributes=frozenset(['requiredExtensions', 'from', 'repeatCount', 'xml:space', 'xlink:href', 'xlink:type', 'attributeType', 'repeatDur', 'id', 'fill', 'onload', 'additive', 'calcMode', 'min', 'keySplines', 'to', 'dur', 'xlink:arcrole', 'onend', 'begin', 'xml:base', 'max', 'xlink:title', 'attributeName', 'onbegin', 'systemLanguage', 'accumulate', 'end', 'externalResourcesRequired', 'by', 'restart', 'xlink:actuate', 'xlink:show', 'xlink:role', 'requiredFeatures', 'xml:lang', 'values', 'keyTimes', 'onrepeat']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'animateColor': SVGElement('animateColor',
+    attributes=frozenset(['requiredExtensions', 'from', 'repeatCount', 'xml:space', 'xlink:href', 'xlink:type', 'attributeType', 'repeatDur', 'id', 'fill', 'onload', 'additive', 'calcMode', 'min', 'keySplines', 'to', 'dur', 'xlink:arcrole', 'onend', 'begin', 'xml:base', 'max', 'xlink:title', 'attributeName', 'onbegin', 'systemLanguage', 'accumulate', 'end', 'externalResourcesRequired', 'by', 'restart', 'xlink:actuate', 'xlink:show', 'xlink:role', 'requiredFeatures', 'xml:lang', 'values', 'keyTimes', 'onrepeat']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'animateMotion': SVGElement('animateMotion',
+    attributes=frozenset(['origin', 'requiredExtensions', 'from', 'repeatCount', 'xml:space', 'xlink:href', 'xlink:type', 'repeatDur', 'id', 'fill', 'onload', 'additive', 'calcMode', 'min', 'keySplines', 'to', 'dur', 'xlink:arcrole', 'onend', 'begin', 'xlink:title', 'xml:base', 'max', 'end', 'keyPoints', 'onbegin', 'systemLanguage', 'accumulate', 'path', 'externalResourcesRequired', 'by', 'restart', 'xlink:actuate', 'xlink:show', 'xlink:role', 'requiredFeatures', 'xml:lang', 'values', 'keyTimes', 'onrepeat', 'rotate']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'mpath', 'title'])),
+
+    'animateTransform': SVGElement('animateTransform',
+    attributes=frozenset(['requiredExtensions', 'from', 'repeatCount', 'xml:space', 'xlink:href', 'xlink:type', 'attributeType', 'repeatDur', 'id', 'fill', 'onload', 'additive', 'calcMode', 'min', 'keySplines', 'to', 'dur', 'xlink:arcrole', 'type', 'onend', 'begin', 'xml:base', 'max', 'xlink:title', 'attributeName', 'onbegin', 'systemLanguage', 'accumulate', 'end', 'externalResourcesRequired', 'by', 'restart', 'xlink:actuate', 'xlink:show', 'xlink:role', 'requiredFeatures', 'xml:lang', 'values', 'keyTimes', 'onrepeat']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'circle': SVGElement('circle',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'cy', 'cx', 'onmouseover', 'externalResourcesRequired', 'id', 'onload', 'style', 'onactivate', 'onmousedown', 'transform', 'class', 'requiredFeatures', 'r', 'onmousemove', 'onclick', 'xml:lang', 'onfocusin', 'systemLanguage']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'metadata', 'desc'])),
+
+    'clipPath': SVGElement('clipPath',
+    attributes=frozenset(['clipPathUnits', 'style', 'xml:base', 'requiredExtensions', 'xml:space', 'transform', 'id', 'requiredFeatures', 'xml:lang', 'externalResourcesRequired', 'class', 'systemLanguage']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'animate', 'text', 'use', 'animateColor', 'polyline', 'path', 'line', 'ellipse', 'rect', 'desc', 'animateMotion', 'polygon', 'title', 'animateTransform', 'circle', 'metadata'])),
+
+    'color-profile': SVGElement('color-profile',
+    attributes=frozenset(['xlink:actuate', 'xlink:show', 'xml:base', 'name', 'rendering-intent', 'xml:space', 'xlink:href', 'xlink:role', 'xml:lang', 'xlink:type', 'xlink:title', 'xlink:arcrole', 'local', 'id']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'cursor': SVGElement('cursor',
+    attributes=frozenset(['xlink:title', 'xml:base', 'requiredExtensions', 'xml:space', 'xlink:href', 'systemLanguage', 'xlink:type', 'externalResourcesRequired', 'id', 'xlink:actuate', 'xlink:show', 'xlink:role', 'requiredFeatures', 'xml:lang', 'y', 'x', 'xlink:arcrole']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'defs': SVGElement('defs',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'class', 'onload', 'style', 'onactivate', 'onmousedown', 'transform', 'id', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'desc': SVGElement('desc',
+    attributes=frozenset(['style', 'xml:lang', 'xml:base', 'xml:space', 'class', 'id']),
+    properties=empty_list,
+    children=frozenset(['*'])),
+
+    'ellipse': SVGElement('ellipse',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'ry', 'cy', 'cx', 'onmouseover', 'externalResourcesRequired', 'id', 'onload', 'style', 'onactivate', 'onmousedown', 'rx', 'transform', 'class', 'requiredFeatures', 'systemLanguage', 'onmousemove', 'onclick', 'xml:lang', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'desc', 'metadata'])),
+
+    'feBlend': SVGElement('feBlend',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'in2', 'height', 'width', 'xml:lang', 'id', 'result', 'in', 'y', 'x', 'class', 'mode']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feColorMatrix': SVGElement('feColorMatrix',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'id', 'height', 'width', 'xml:lang', 'values', 'result', 'in', 'y', 'x', 'type', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feComponentTransfer': SVGElement('feComponentTransfer',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'height', 'width', 'xml:lang', 'id', 'result', 'in', 'y', 'x', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['feFuncA', 'feFuncR', 'feFuncB', 'feFuncG'])),
+
+    'feComposite': SVGElement('feComposite',
+    attributes=frozenset(['xml:base', 'xml:space', 'in2', 'height', 'result', 'in', 'operator', 'class', 'style', 'width', 'id', 'k3', 'k2', 'k1', 'xml:lang', 'k4', 'y', 'x']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feConvolveMatrix': SVGElement('feConvolveMatrix',
+    attributes=frozenset(['xml:base', 'xml:space', 'kernelUnitLength', 'edgeMode', 'height', 'bias', 'result', 'in', 'preserveAlpha', 'id', 'style', 'divisor', 'kernelMatrix', 'width', 'xml:lang', 'targetX', 'targetY', 'y', 'x', 'class2', 'order']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feDiffuseLighting': SVGElement('feDiffuseLighting',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'diffuseConstant', 'height', 'kernelUnitLength', 'width', 'xml:lang', 'id', 'result', 'in', 'y', 'x', 'class', 'surfaceScale']),
+    properties=presentation_attributes,
+    children=frozenset(['fePointLight', 'feSpotLight', 'title', 'metadata', 'feDistantLight', 'desc'])),
+
+    'feDisplacementMap': SVGElement('feDisplacementMap',
+    attributes=frozenset(['xml:base', 'xml:space', 'yChannelSelector', 'in2', 'height', 'result', 'in', 'class', 'style', 'scale', 'id', 'width', 'xml:lang', 'xChannelSelector', 'y', 'x']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feDistantLight': SVGElement('feDistantLight',
+    attributes=frozenset(['xml:lang', 'elevation', 'azimuth', 'xml:base', 'xml:space', 'id']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feFlood': SVGElement('feFlood',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'height', 'width', 'xml:lang', 'id', 'result', 'y', 'x', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set', 'animateColor'])),
+
+    'feFuncA': SVGElement('feFuncA',
+    attributes=frozenset(['slope', 'xml:base', 'tableValues', 'xml:space', 'xml:lang', 'intercept', 'amplitude', 'offset', 'type', 'id', 'exponent']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feFuncB': SVGElement('feFuncB',
+    attributes=frozenset(['slope', 'xml:base', 'tableValues', 'xml:space', 'xml:lang', 'intercept', 'amplitude', 'offset', 'type', 'id', 'exponent']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feFuncG': SVGElement('feFuncG',
+    attributes=frozenset(['slope', 'xml:base', 'tableValues', 'xml:space', 'xml:lang', 'intercept', 'amplitude', 'offset', 'type', 'id', 'exponent']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feFuncR': SVGElement('feFuncR',
+    attributes=frozenset(['slope', 'xml:base', 'tableValues', 'xml:space', 'xml:lang', 'intercept', 'amplitude', 'offset', 'type', 'id', 'exponent']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feGaussianBlur': SVGElement('feGaussianBlur',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'height', 'width', 'xml:lang', 'id', 'result', 'in', 'y', 'x', 'stdDeviation', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feImage': SVGElement('feImage',
+    attributes=frozenset(['xlink:title', 'xml:base', 'xml:space', 'xlink:href', 'height', 'result', 'xlink:type', 'externalResourcesRequired', 'preserveAsectRatio', 'class', 'xlink:actuate', 'style', 'xlink:show', 'id', 'xlink:role', 'width', 'xml:lang', 'y', 'x', 'xlink:arcrole']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set', 'animateColor'])),
+
+    'feMerge': SVGElement('feMerge',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'height', 'width', 'xml:lang', 'id', 'result', 'y', 'x', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set', 'feMergeNode'])),
+
+    'feMergeNode': SVGElement('feMergeNode',
+    attributes=frozenset(['xml:space', 'xml:lang', 'xml:base', 'id', 'in']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feMorphology': SVGElement('feMorphology',
+    attributes=frozenset(['style', 'xml:base', 'y', 'xml:space', 'id', 'height', 'width', 'xml:lang', 'radius', 'result', 'in', 'operator', 'x', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feOffset': SVGElement('feOffset',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'in', 'height', 'width', 'xml:lang', 'id', 'result', 'dx', 'dy', 'y', 'x', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'fePointLight': SVGElement('fePointLight',
+    attributes=frozenset(['xml:lang', 'xml:base', 'y', 'x', 'xml:space', 'z', 'id']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feSpecularLighting': SVGElement('feSpecularLighting',
+    attributes=frozenset(['specularConstant', 'xml:base', 'xml:space', 'kernelUnitLength', 'height', 'result', 'in', 'class', 'style', 'id', 'width', 'xml:lang', 'specularExponent', 'y', 'x', 'surfaceScale']),
+    properties=presentation_attributes,
+    children=frozenset(['fePointLight', 'feSpotLight', 'title', 'metadata', 'feDistantLight', 'desc'])),
+
+    'feSpotLight': SVGElement('feSpotLight',
+    attributes=frozenset(['pointsAtX', 'xml:base', 'xml:space', 'limitingConeAngle', 'xml:lang', 'specularExponent', 'pointsAtZ', 'y', 'x', 'pointsAtY', 'z', 'id']),
+    properties=empty_list,
+    children=frozenset(['animate', 'set'])),
+
+    'feTile': SVGElement('feTile',
+    attributes=frozenset(['style', 'xml:base', 'xml:space', 'height', 'width', 'xml:lang', 'id', 'result', 'in', 'y', 'x', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set'])),
+
+    'feTurbulence': SVGElement('feTurbulence',
+    attributes=frozenset(['xml:base', 'baseFrequency', 'xml:space', 'stitchTiles', 'height', 'width', 'xml:lang', 'id', 'result', 'x', 'y', 'numOctaves', 'type', 'seed']),
+    properties=presentation_attributes,
+    children=empty_list),
+
+    'filter': SVGElement('filter',
+    attributes=frozenset(['xlink:title', 'xml:base', 'xml:space', 'xlink:href', 'height', 'xlink:type', 'externalResourcesRequired', 'class', 'xlink:actuate', 'style', 'xlink:show', 'filterRes', 'primitiveUnits', 'id', 'xlink:role', 'width', 'xml:lang', 'y', 'x', 'xlink:arcrole', 'filterUnits']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'animate', 'metadata', 'desc', 'feBlend', 'feColorMatrix', 'feComponentTransfer',
+                               'feComposite', 'feConvolveMatrix', 'feDiffuseLighting',
+                               'feDisplacementMap', 'feFlood', 'feGaussianBlur',
+                               'feImage', 'feMerge', 'feMorphology', 'feOffset',
+                               'feSpecularLighting', 'feTile', 'feTurbulence'])),
+    'font': SVGElement('font',
+    attributes=frozenset(['xml:space', 'id', 'xml:lang', 'xml:base', 'class', 'style', 'externalResourcesRequired', 'horiz-origin-x', 'horiz-origin-y', 'horiz-adv-x', 'vert-origin-x', 'vert-origin-y', 'vert-adv-y']),
+    properties=presentation_attributes,
+    children=frozenset(['title', 'metadata', 'missing-glyph', 'font-face', 'vkern', 'hkern', 'glyph', 'desc'])),
+
+    'font-face': SVGElement('font-face',
+    attributes=frozenset(['mathematical', 'slope', 'font-size', 'xml:space', 'v-hanging', 'hanging', 'overline-thickness', 'ascent', 'id', 'strikethrough-position', 'underline-position', 'descent', 'cap-height', 'units-per-em', 'font-style', 'unicode-range', 'font-stretch', 'font-variant', 'x-height', 'font-weight', 'xml:base', 'panose-1', 'strikethrough-thickness', 'stemh', 'v-alphabetic', 'stemv', 'bbox', 'underline-thickness', 'font-family', 'v-mathematical', 'v-ideographic', 'ideographic', 'overline-position', 'widths', 'xml:lang', 'accent-height', 'alphabetic']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'font-face-src', 'title'])),
+
+    'font-face-format': SVGElement('font-face-format',
+    attributes=frozenset(['xml:space', 'xml:lang', 'xml:base', 'id']),
+    properties=empty_list,
+    children=empty_list),
+
+    'font-face-name': SVGElement('font-face-name',
+    attributes=frozenset(['xml:space', 'xml:lang', 'xml:base', 'id', 'name']),
+    properties=empty_list,
+    children=empty_list),
+
+    'font-face-uri': SVGElement('font-face-uri',
+    attributes=frozenset(['xlink:actuate', 'xlink:show', 'xml:base', 'xml:space', 'xlink:href', 'xlink:role', 'xml:lang', 'xlink:type', 'xlink:title', 'xlink:arcrole', 'id']),
+    properties=empty_list,
+    children=frozenset(['font-face-format'])),
+
+    'foreignObject': SVGElement('foreignObject',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'height', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'id', 'onload', 'style', 'onactivate', 'onmousedown', 'transform', 'class', 'width', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'y', 'x', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['*'])),
+
+    'g': SVGElement('g',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'class', 'onload', 'style', 'onactivate', 'onmousedown', 'transform', 'id', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'glyph': SVGElement('glyph',
+    attributes=frozenset(['xml:base', 'xml:space', 'id', 'xml:lang', 'class', 'style','d','horiz-adv-x', 'vert-origin-x', 'vert-origin-y', 'vert-adv-y', 'unicode', 'glyph-name', 'orientation', 'arabic-form', 'lang']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'glyphRef': SVGElement('glyphRef',
+    attributes=frozenset(['xlink:title', 'xml:base', 'format', 'xml:space', 'xlink:href', 'dx', 'dy', 'xlink:type', 'class', 'xlink:actuate', 'style', 'xlink:show', 'id', 'xlink:role', 'xml:lang', 'y', 'x', 'xlink:arcrole', 'glyphRef']),
+    properties=presentation_attributes,
+    children=empty_list),
+
+    'hkern': SVGElement('hkern',
+    attributes=frozenset(['xml:base', 'g2', 'g1', 'xml:space', 'u1', 'u2', 'xml:lang', 'id', 'k']),
+    properties=empty_list,
+    children=empty_list),
+
+    'image': SVGElement('image',
+    attributes=frozenset(['requiredExtensions', 'onfocusout', 'xml:space', 'xlink:href', 'height', 'id', 'onload', 'style', 'onmousedown', 'transform', 'width', 'onmousemove', 'onclick', 'xlink:arcrole', 'onfocusin', 'xml:base', 'onmouseup', 'onmouseout', 'xlink:title', 'systemLanguage', 'onmouseover', 'xlink:type', 'externalResourcesRequired', 'class', 'xlink:actuate', 'xlink:show', 'onactivate', 'xlink:role', 'requiredFeatures', 'xml:lang', 'y', 'x', 'preserveAspectRatio']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'desc', 'metadata'])),
+
+    'line': SVGElement('line',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'x2', 'systemLanguage', 'onmouseover', 'y1', 'externalResourcesRequired', 'y2', 'id', 'onload', 'style', 'x1', 'onactivate', 'onmousedown', 'transform', 'class', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'desc', 'metadata'])),
+
+    'linearGradient': SVGElement('linearGradient',
+    attributes=frozenset(['xlink:title', 'xml:base', 'xml:space', 'xlink:href', 'x2', 'y1', 'externalResourcesRequired', 'y2', 'class', 'xlink:actuate', 'xlink:role', 'style', 'xlink:show', 'spreadMethod', 'id', 'gradientUnits', 'xml:lang', 'gradientTransform', 'xlink:type', 'xlink:arcrole', 'x1']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'title', 'animate', 'animateTransform', 'stop', 'metadata', 'desc'])),
+
+    'marker': SVGElement('marker',
+    attributes=frozenset(['xml:space', 'id', 'xml:lang', 'xml:base', 'class', 'style', 'externalResourcesRequired', 'viewBox', 'preserveAspectRatio', 'refX', 'refY', 'markerUnits', 'markerWidth',  'markerHeight', 'orient']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'mask': SVGElement('mask',
+    attributes=frozenset(['xml:base', 'requiredExtensions', 'xml:space', 'height', 'systemLanguage', 'externalResourcesRequired', 'maskContentUnits', 'class', 'style', 'id', 'width', 'requiredFeatures', 'xml:lang', 'y', 'x', 'maskUnits']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'metadata': SVGElement('metadata',
+    attributes=frozenset(['xml:space', 'xml:lang', 'xml:base', 'id']),
+    properties=empty_list,
+    children=frozenset(['*'])),
+
+    'missing-glyph': SVGElement('missing-glyph',
+    attributes=frozenset(['xml:base', 'xml:space', 'id', 'xml:lang', 'class', 'style', 'd', 'horiz-adv-x', 'vert-origin-x', 'vert-origin-y', 'vert-adv-y']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'mpath': SVGElement('mpath',
+    attributes=frozenset(['xlink:actuate', 'xlink:show', 'xml:base', 'xml:space', 'xlink:href', 'id', 'xlink:role', 'xml:lang', 'xlink:type', 'xlink:title', 'xlink:arcrole', 'externalResourcesRequired']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'path': SVGElement('path',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'systemLanguage', 'onmouseover', 'pathLength', 'externalResourcesRequired', 'id', 'onload', 'style', 'd', 'onactivate', 'onmousedown', 'transform', 'class', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'desc', 'metadata'])),
+
+    'pattern': SVGElement('pattern',
+    attributes=frozenset(['xlink:title', 'xml:base', 'requiredExtensions', 'xml:space', 'xlink:href', 'height', 'class', 'systemLanguage', 'patternContentUnits', 'xlink:type', 'externalResourcesRequired', 'id', 'xlink:actuate', 'style', 'xlink:show', 'viewBox', 'xlink:role', 'width', 'requiredFeatures', 'patternUnits', 'patternTransform', 'y', 'x', 'preserveAspectRatio', 'xlink:arcrole', 'xml:lang']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'polygon': SVGElement('polygon',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'id', 'onload', 'style', 'onactivate', 'onmousedown', 'transform', 'class', 'requiredFeatures', 'points', 'onmousemove', 'onclick', 'xml:lang', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'desc', 'metadata'])),
+
+    'polyline': SVGElement('polyline',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'id', 'onload', 'style', 'onactivate', 'onmousedown', 'transform', 'class', 'requiredFeatures', 'points', 'onmousemove', 'onclick', 'xml:lang', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'desc', 'metadata'])),
+
+    'radialGradient': SVGElement('radialGradient',
+    attributes=frozenset(['xlink:title', 'xml:base', 'fx', 'fy', 'xml:space', 'xlink:href', 'cy', 'cx', 'xlink:type', 'externalResourcesRequired', 'r', 'id', 'xlink:actuate', 'gradientUnits', 'style', 'xlink:show', 'spreadMethod', 'class', 'xlink:role', 'xml:lang', 'gradientTransform', 'xlink:arcrole']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'title', 'animate', 'animateTransform', 'stop', 'metadata', 'desc'])),
+
+    'rect': SVGElement('rect',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'height', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'id', 'onload', 'style', 'ry', 'onactivate', 'onmousedown', 'rx', 'transform', 'class', 'width', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'y', 'x', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'metadata', 'desc'])),
+
+    'script': SVGElement('script',
+    attributes=frozenset(['xlink:actuate', 'xlink:show', 'xml:base', 'xml:space', 'xlink:href', 'id', 'xlink:role', 'xml:lang', 'xlink:type', 'xlink:title', 'xlink:arcrole', 'type', 'externalResourcesRequired']),
+    properties=empty_list,
+    children=empty_list),
+
+    'set': SVGElement('set',
+    attributes=frozenset(['begin', 'xlink:title', 'xml:base', 'requiredExtensions', 'repeatCount', 'xml:space', 'xlink:href', 'attributeName', 'onbegin', 'systemLanguage', 'attributeType', 'xlink:type', 'externalResourcesRequired', 'id', 'restart', 'fill', 'xlink:actuate', 'onload', 'xlink:show', 'end', 'min', 'repeatDur', 'xlink:role', 'to', 'requiredFeatures', 'xml:lang', 'max', 'dur', 'xlink:arcrole', 'onrepeat', 'onend']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'stop': SVGElement('stop',
+    attributes=frozenset(['xml:base', 'xml:space', 'xml:lang', 'offset', 'style', 'class']),
+    properties=presentation_attributes,
+    children=frozenset(['animate', 'set', 'animateColor'])),
+
+    'style': SVGElement('style',
+    attributes=frozenset(['xml:lang', 'xml:base', 'title', 'media', 'xml:space', 'type', 'id']),
+    properties=empty_list,
+    children=frozenset(['*'])),
+
+    'svg': SVGElement('svg',
+    attributes=frozenset(['requiredExtensions', 'onerror', 'onfocusout', 'xml:space', 'height', 'onscroll', 'baseProfile', 'contentStyleType', 'id', 'onabort', 'onload', 'style', 'onmousedown', 'onzoom', 'onresize', 'width', 'version', 'onmousemove', 'onmouseup', 'xmlns:xlink', 'xmlns:ev', 'onfocusin', 'xml:base', 'onclick', 'onmouseout', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'zoomAndPan', 'class', 'onunload', 'xmlns', 'onactivate', 'viewBox', 'requiredFeatures', 'xml:lang', 'y', 'x', 'preserveAspectRatio', 'contentScriptType']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'switch': SVGElement('switch',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'systemLanguage', 'onmouseover', 'externalResourcesRequired', 'class', 'onload', 'style', 'onactivate', 'onmousedown', 'transform', 'id', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'line', 'use', 'animateColor', 'polyline', 'path', 'animate', 'ellipse', 'rect', 'desc', 'a', 'animateMotion', 'polygon', 'g', 'title', 'svg', 'switch', 'animateTransform', 'foreignObject', 'circle', 'metadata'])),
+
+    'symbol': SVGElement('symbol',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'onfocusout', 'xml:space', 'onmouseover', 'id', 'externalResourcesRequired', 'viewBox', 'onload', 'style', 'onactivate', 'onmousedown', 'class', 'xml:lang', 'onmousemove', 'onclick', 'preserveAspectRatio', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'text', 'image', 'font-face', 'polyline', 'marker', 'animate', 'font', 'color-profile', 'ellipse', 'cursor', 'style', 'polygon', 'title', 'pattern', 'circle', 'radialGradient', 'metadata', 'defs', 'symbol', 'use', 'animateMotion', 'animateColor', 'path', 'line', 'rect', 'desc', 'a', 'g', 'svg', 'script', 'mask', 'altGlyphDef', 'filter', 'switch', 'animateTransform', 'linearGradient', 'clipPath', 'foreignObject', 'view'])),
+
+    'text': SVGElement('text',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'class', 'systemLanguage', 'onmouseover', 'dx', 'dy', 'externalResourcesRequired', 'lengthAdjust', 'onload', 'style', 'rotate', 'onactivate', 'onmousedown', 'textLength', 'transform', 'id', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'y', 'x', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['a', 'animateMotion', 'set', 'title', 'textPath', 'tspan', 'animateColor', 'tref', 'animateTransform', 'altGlyph', 'animate', 'desc', 'metadata'])),
+
+    'textPath': SVGElement('textPath',
+    attributes=frozenset(['requiredExtensions', 'onfocusout', 'xml:space', 'xlink:href', 'startOffset', 'id', 'onload', 'style', 'onmousedown', 'lengthAdjust', 'onmousemove', 'onclick', 'xlink:arcrole', 'onfocusin', 'xml:base', 'onmouseup', 'onmouseout', 'xlink:title', 'spacing', 'systemLanguage', 'onmouseover', 'xlink:type', 'externalResourcesRequired', 'class', 'xlink:actuate', 'xlink:show', 'onactivate', 'textLength', 'method', 'xlink:role', 'requiredFeatures', 'xml:lang']),
+    properties=presentation_attributes,
+    children=frozenset(['a', 'set', 'title', 'tspan', 'animateColor', 'tref', 'altGlyph', 'animate', 'metadata', 'desc'])),
+
+    'title': SVGElement('title',
+    attributes=frozenset(['style', 'xml:lang', 'xml:base', 'xml:space', 'class', 'id']),
+    properties=empty_list,
+    children=frozenset(['*'])),
+
+    'tref': SVGElement('tref',
+    attributes=frozenset(['requiredExtensions', 'onfocusout', 'xml:space', 'xlink:href', 'id', 'onload', 'style', 'onmousedown', 'lengthAdjust', 'onmousemove', 'onclick', 'xlink:arcrole', 'onfocusin', 'xml:base', 'onmouseup', 'onmouseout', 'xlink:title', 'systemLanguage', 'onmouseover', 'dx', 'dy', 'xlink:type', 'externalResourcesRequired', 'class', 'xlink:actuate', 'xlink:show', 'onactivate', 'textLength', 'xlink:role', 'requiredFeatures', 'xml:lang', 'y', 'x', 'rotate']),
+    properties=presentation_attributes,
+    children=frozenset(['set', 'title', 'animate', 'metadata', 'animateColor', 'desc'])),
+
+    'tspan': SVGElement('tspan',
+    attributes=frozenset(['xml:base', 'onmouseup', 'onmouseout', 'requiredExtensions', 'onfocusout', 'xml:space', 'class', 'systemLanguage', 'onmouseover', 'dx', 'dy', 'externalResourcesRequired', 'lengthAdjust', 'onload', 'style', 'rotate', 'onactivate', 'onmousedown', 'textLength', 'id', 'requiredFeatures', 'xml:lang', 'onmousemove', 'onclick', 'y', 'x', 'onfocusin']),
+    properties=presentation_attributes,
+    children=frozenset(['a', 'set', 'title', 'tspan', 'animateColor', 'tref', 'altGlyph', 'animate', 'metadata', 'desc'])),
+
+    'use': SVGElement('use',
+    attributes=frozenset(['requiredExtensions', 'onfocusout', 'xml:space', 'xlink:href', 'height', 'id', 'onload', 'style', 'onmousedown', 'transform', 'width', 'onmousemove', 'onclick', 'xlink:arcrole', 'onfocusin', 'xml:base', 'onmouseup', 'onmouseout', 'xlink:title', 'systemLanguage', 'onmouseover', 'xlink:type', 'externalResourcesRequired', 'class', 'xlink:actuate', 'xlink:show', 'onactivate', 'xlink:role', 'requiredFeatures', 'xml:lang', 'y', 'x']),
+    properties=presentation_attributes,
+    children=frozenset(['animateMotion', 'set', 'title', 'animateColor', 'animateTransform', 'animate', 'desc', 'metadata'])),
+
+    'view': SVGElement('view',
+    attributes=frozenset(['xml:base', 'viewTarget', 'xml:space', 'viewBox', 'xml:lang', 'preserveAspectRatio', 'externalResourcesRequired', 'zoomAndPan', 'id']),
+    properties=empty_list,
+    children=frozenset(['desc', 'metadata', 'title'])),
+
+    'vkern': SVGElement('vkern',
+    attributes=frozenset(['xml:base', 'g2', 'g1', 'xml:space', 'u1', 'u2', 'xml:lang', 'id', 'k']),
+    properties=empty_list,
+    children=empty_list),
+
+}

falcon/lib/python3.10/site-packages/svgwrite/data/pattern.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman --<mozman@gmx.at>
+# Purpose: pattern module
+# Created: 27.09.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+
+import re
+
+#coordinate ::= number ("em" | "ex" | "px" | "in" | "cm" | "mm" | "pt" | "pc" | "%")?
+coordinate = re.compile(r"(^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)(cm|em|ex|in|mm|pc|pt|px|%)?$")
+
+#length ::= number ("em" | "ex" | "px" | "in" | "cm" | "mm" | "pt" | "pc" | "%")?
+length = coordinate
+
+#angle ::= number (~"deg" | ~"grad" | ~"rad")?
+angle = re.compile(r"(^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)(deg|rad|grad)?$")
+
+# numbers without units
+number = re.compile(r"(^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)$")
+
+# number as percentage value '###%'
+percentage = re.compile(r"(^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)%$")
+
+#frequency ::= number (~"Hz" | ~"kHz")
+frequency = re.compile(r"(^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)(Hz|kHz)?$")
+
+#time ::= number (~"s" | ~"ms")
+time = re.compile(r"(^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)(s|ms)?$")

falcon/lib/python3.10/site-packages/svgwrite/data/typechecker.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman --<mozman@gmx.at>
+# Purpose: typechecker
+# Created: 15.10.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+
+import re
+
+from svgwrite.data import pattern
+from svgwrite.data.colors import colornames
+from svgwrite.data.svgparser import is_valid_transferlist, is_valid_pathdata, is_valid_animation_timing
+from svgwrite.utils import is_string
+
+def iterflatlist(values):
+    """ Flatten nested *values*, returns an *iterator*. """
+    for element in values:
+        if hasattr(element, "__iter__") and not is_string(element):
+            for item in iterflatlist(element):
+                yield item
+        else:
+            yield element
+
+INVALID_NAME_CHARS = frozenset([' ', '\t', '\r', '\n', ',', '(', ')'])
+WHITESPACE = frozenset([' ', '\t', '\r', '\n'])
+SHAPE_PATTERN = re.compile(r"^rect\((.*),(.*),(.*),(.*)\)$")
+FUNCIRI_PATTERN = re.compile(r"^url\((.*)\)$")
+ICCCOLOR_PATTERN = re.compile(r"^icc-color\((.*)\)$")
+COLOR_HEXDIGIT_PATTERN = re.compile(r"^#[a-fA-F0-9]{3}([a-fA-F0-9]{3})?$")
+COLOR_RGB_INTEGER_PATTERN = re.compile(r"^rgb\( *\d+ *, *\d+ *, *\d+ *\)$")
+COLOR_RGB_PERCENTAGE_PATTERN = re.compile(r"^rgb\( *\d+(\.\d*)?% *, *\d+(\.\d*)?% *, *\d+(\.\d*)?% *\)$")
+NMTOKEN_PATTERN = re.compile(r"^[a-zA-Z_:][\w\-\.:]*$")
+
+
+class Full11TypeChecker(object):
+    def get_version(self):
+        return '1.1', 'full'
+
+    def is_angle(self, value):
+        #angle ::= number (~"deg" | ~"grad" | ~"rad")?
+        if self.is_number(value):
+            return True
+        elif is_string(value):
+            return pattern.angle.match(value.strip()) is not None
+        return False
+
+    def is_anything(self, value):
+        #anything ::= Char*
+        return bool(str(value).strip())
+    is_string = is_anything
+    is_content_type = is_anything
+
+    def is_color(self, value):
+        #color    ::= "#" hexdigit hexdigit hexdigit (hexdigit hexdigit hexdigit)?
+        #             | "rgb(" wsp* integer comma integer comma integer wsp* ")"
+        #             | "rgb(" wsp* number "%" comma number "%" comma number "%" wsp* ")"
+        #             | color-keyword
+        #hexdigit ::= [0-9A-Fa-f]
+        #comma    ::= wsp* "," wsp*
+        value = str(value).strip()
+        if value.startswith('#'):
+            if COLOR_HEXDIGIT_PATTERN.match(value):
+                return True
+            else:
+                return False
+        elif value.startswith('rgb('):
+            if COLOR_RGB_INTEGER_PATTERN.match(value):
+                return True
+            elif COLOR_RGB_PERCENTAGE_PATTERN.match(value):
+                return True
+            return False
+        return self.is_color_keyword(value)
+
+    def is_color_keyword(self, value):
+        return value.strip() in colornames
+
+    def is_frequency(self, value):
+        # frequency ::= number (~"Hz" | ~"kHz")
+        if self.is_number(value):
+            return True
+        elif is_string(value):
+            return pattern.frequency.match(value.strip()) is not None
+        return False
+
+    def is_FuncIRI(self, value):
+        # FuncIRI ::= "url(" <IRI> ")"
+        res = FUNCIRI_PATTERN.match(str(value).strip())
+        if res:
+            return self.is_IRI(res.group(1))
+        return False
+
+    def is_icccolor(self, value):
+        # icccolor ::= "icc-color(" name (comma-wsp number)+ ")"
+        res = ICCCOLOR_PATTERN.match(str(value).strip())
+        if res:
+            return self.is_list_of_T(res.group(1), 'name')
+        return False
+
+    def is_integer(self, value):
+        if isinstance(value, float):
+            return False
+        try:
+            number = int(value)
+            return True
+        except:
+            return False
+
+    def is_IRI(self, value):
+        # Internationalized Resource Identifiers
+        # a more generalized complement to Uniform Resource Identifiers (URIs)
+        # nearly everything can be a valid <IRI>
+        # only a none-empty string ist a valid input
+        if is_string(value):
+            return bool(value.strip())
+        else:
+            return False
+
+    def is_length(self, value):
+        # length ::= number ("em" | "ex" | "px" | "in" | "cm" | "mm" | "pt" | "pc" | "%")?
+        if value is None:
+            return False
+        if isinstance(value, (int, float)):
+            return self.is_number(value)
+        elif is_string(value):
+            result = pattern.length.match(value.strip())
+            if result:
+                number, tmp, unit = result.groups()
+                return self.is_number(number) # for tiny check!
+        return False
+
+    is_coordinate = is_length
+
+    def is_list_of_T(self, value, t='string'):
+        def split(value):
+            #TODO: improve split function!!!!
+            if isinstance(value, (int, float)):
+                return (value, )
+            if is_string(value):
+                return iterflatlist(v.split(',') for v in value.split(' '))
+            return value
+        #list-of-Ts ::= T
+        #               | T comma-wsp list-of-Ts
+        #comma-wsp  ::= (wsp+ ","? wsp*) | ("," wsp*)
+        #wsp        ::= (#x20 | #x9 | #xD | #xA)
+        checker = self.get_func_by_name(t)
+        for v in split(value):
+            if not checker(v):
+                return False
+        return True
+
+    def is_four_numbers(self, value):
+        def split(value):
+            if is_string(value):
+                values = iterflatlist( (v.strip().split(' ') for v in value.split(',')) )
+                return (v for v in values if v)
+            else:
+                return iterflatlist(value)
+
+        values = list(split(value))
+        if len(values) != 4:
+            return False
+        checker = self.get_func_by_name('number')
+        for v in values:
+            if not checker(v):
+                return False
+        return True
+
+    def is_semicolon_list(self, value):
+        #a semicolon-separated list of values
+        #               | value comma-wsp list-of-values
+        #comma-wsp  ::= (wsp+ ";" wsp*) | ("," wsp*)
+        #wsp        ::= (#x20 | #x9 | #xD | #xA)
+        return self.is_list_of_T(value.replace(';', ' '), 'string')
+
+    def is_name(self, value):
+        # name  ::= [^,()#x20#x9#xD#xA] /* any char except ",", "(", ")" or wsp */
+        chars = frozenset(str(value).strip())
+        if not chars or INVALID_NAME_CHARS.intersection(chars):
+            return False
+        else:
+            return True
+
+    def is_number(self, value):
+        try:
+            number = float(value)
+            return True
+        except:
+            return False
+
+    def is_number_optional_number(self, value):
+        #number-optional-number ::= number
+        #                           | number comma-wsp number
+        if is_string(value):
+            values = re.split('[ ,]+', value.strip())
+            if 0 < len(values) < 3: # 1 or 2 numbers
+                for v in values:
+                    if not self.is_number(v):
+                        return False
+                return True
+        else:
+            try: # is it a 2-tuple
+                n1, n2 = value
+                if self.is_number(n1) and \
+                   self.is_number(n2):
+                    return True
+            except TypeError: # just one value
+                return self.is_number(value)
+            except ValueError: # more than 2 values
+                pass
+        return False
+
+    def is_paint(self, value):
+        #paint ::=	"none" |
+        #           "currentColor" |
+        #           <color> [<icccolor>] |
+        #           <funciri> [ "none" | "currentColor" | <color> [<icccolor>] |
+        #           "inherit"
+        def split_values(value):
+            try:
+                funcIRI, value = value.split(")", 1)
+                values = [funcIRI+")"]
+                values.extend(split_values(value))
+                return values
+            except ValueError:
+                return value.split()
+
+        values = split_values(str(value).strip())
+        for value in [v.strip() for v in values]:
+            if value in ('none', 'currentColor', 'inherit'):
+                continue
+            elif self.is_color(value):
+                continue
+            elif self.is_icccolor(value):
+                continue
+            elif self.is_FuncIRI(value):
+                continue
+            return False
+        return True
+
+    def is_percentage(self, value):
+        #percentage ::= number "%"
+        if self.is_number(value):
+            return True
+        elif is_string(value):
+            return pattern.percentage.match(value.strip()) is not None
+        return False
+
+    def is_time(self, value):
+        #time ::= <number> (~"ms" | ~"s")?
+        if self.is_number(value):
+            return True
+        elif is_string(value):
+            return pattern.time.match(value.strip()) is not None
+        return False
+
+    def is_transform_list(self, value):
+        if is_string(value):
+            return is_valid_transferlist(value)
+        else:
+            return False
+
+    def is_path_data(self, value):
+        if is_string(value):
+            return is_valid_pathdata(value)
+        else:
+            return False
+
+    def is_XML_Name(self, value):
+        # http://www.w3.org/TR/2006/REC-xml-20060816/#NT-Name
+        # Nmtoken
+        return bool(NMTOKEN_PATTERN.match(str(value).strip()))
+
+    def is_shape(self, value):
+        # shape ::= (<top> <right> <bottom> <left>)
+        # where <top>, <bottom> <right>, and <left> specify offsets from the
+        # respective sides of the box.
+        # <top>, <right>, <bottom>, and <left> are <length> values
+        # i.e. 'rect(5px, 10px, 10px, 5px)'
+        res = SHAPE_PATTERN.match(value.strip())
+        if res:
+            for arg in res.groups():
+                if arg.strip() == 'auto':
+                    continue
+                if not self.is_length(arg):
+                    return False
+        else:
+            return False
+        return True
+
+    def is_timing_value_list(self, value):
+        if is_string(value):
+            return is_valid_animation_timing(value)
+        else:
+            return False
+
+    def is_list_of_text_decoration_style(self, value):
+        return self.is_list_of_T(value, t='text_decoration_style')
+
+    def is_text_decoration_style(self, value):
+        return value in ('overline', 'underline', 'line-through', 'blink')
+
+    def get_func_by_name(self, funcname):
+        return getattr(self,
+                       'is_'+funcname.replace('-', '_'),
+                       self.is_anything)
+
+    def check(self, typename, value):
+        if typename.startswith('list-of-'):
+            t = typename[8:]
+            return self.is_list_of_T(value, t)
+        return self.get_func_by_name(typename)(value)
+
+
+FOCUS_CONST = frozenset(['nav-next', 'nav-prev', 'nav-up', 'nav-down', 'nav-left',
+                         'nav-right', 'nav-up-left', 'nav-up-right', 'nav-down-left',
+                         'nav-down-right'])
+
+
+class Tiny12TypeChecker(Full11TypeChecker):
+    def get_version(self):
+        return '1.2', 'tiny'
+
+    def is_boolean(self, value):
+        if isinstance(value, bool):
+            return True
+        if is_string(value):
+            return value.strip().lower() in ('true', 'false')
+        return False
+
+    def is_number(self, value):
+        try:
+            number = float(value)
+            if -32767.9999 <= number <= 32767.9999:
+                return True
+            else:
+                return False
+        except:
+            return False
+
+    def is_focus(self, value):
+        return str(value).strip() in FOCUS_CONST

falcon/lib/python3.10/site-packages/svgwrite/data/types.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman --<mozman@gmx.at>
+# Purpose: svg types
+# Created: 30.09.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+
+
+class SVGAttribute(object):
+    def __init__(self, name, anim, types, const):
+        self.name = name
+        self._anim = anim
+        self._types = types
+        self._const = const
+
+    # 'elementname' is ignored, but necessary because of the signatures of
+    # the SVGMultiAttribute class methods get_...()
+
+    def get_anim(self, elementname='*'):
+        return self._anim
+
+    def get_types(self, elementname='*'):
+        return self._types
+
+    def get_const(self, elementname='*'):
+        return self._const
+
+
+class SVGMultiAttribute(object):
+    # example: SVGMultiAttribute({'*':SVGAttribute(...), 'text tref':SVGAttribute(...)} )
+    # parametr is a dict-like object
+    # '*' is the default attribute definition
+    # 'text' and 'tref' share the same attribute definition
+
+    def __init__(self, attributes):
+        self.name = None
+        self._attributes = {}
+
+        for names, attribute in attributes.items():
+            for name in names.split():
+                name = name.strip()
+                self._attributes[name] = attribute
+                if not self.name:
+                    self.name = attribute.name
+                elif self.name != attribute.name:
+                    raise ValueError("Different attribute-names for SVGMultiAttribute "\
+                                     "(%s != %s)." % (self.name, attribute.name))
+
+        if '*' not in self._attributes and len(self._attributes):
+            # if no default attribute definition were given
+            # set the first attribute definition as the default attribute definition
+            firstkey = sorted(self._attributes.keys())[0]
+            self._attributes['*'] = self._attributes[firstkey]
+
+    def get_attribute(self, elementname):
+        if elementname in self._attributes:
+            return self._attributes[elementname]
+        else:
+            return self._attributes['*']
+
+    def get_anim(self, elementname='*'):
+        attribute = self.get_attribute(elementname)
+        return attribute.get_anim()
+
+    def get_types(self, elementname='*'):
+        attribute = self.get_attribute(elementname)
+        return attribute.get_types()
+
+    def get_const(self, elementname='*'):
+        attribute = self.get_attribute(elementname)
+        return attribute.get_const()
+
+
+class SVGElement(object):
+    def __init__(self, name, attributes, properties, children):
+        self.name = name
+        s = set(attributes)
+        s.update(properties)
+        self.valid_attributes = frozenset(s)
+        self.valid_children = frozenset(children)

falcon/lib/python3.10/site-packages/svgwrite/drawing.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman
+# Purpose: drawing
+# Created: 10.09.2010
+# Copyright (C) 2010, Manfred Moitzi
+# License: MIT License
+"""
+The *Drawing* object is the overall container for all SVG
+elements. It provides the methods to store the drawing into a file or a
+file-like object. If you want to use stylesheets, the reference links
+to this stylesheets were also stored (`add_stylesheet`)
+in the *Drawing* object.
+
+set/get SVG attributes::
+
+    element['attribute'] = value
+    value = element['attribute']
+
+The Drawing object also includes a defs section, add elements to the defs
+section by::
+
+    drawing.defs.add(element)
+
+"""
+import io
+
+from svgwrite.container import SVG, Defs
+from svgwrite.elementfactory import ElementFactory
+from svgwrite.utils import pretty_xml
+
+
+class Drawing(SVG, ElementFactory):
+    """ This is the SVG drawing represented by the top level *svg* element.
+
+    A drawing consists of any number of SVG elements contained within the drawing
+    element, stored in the *elements* attribute.
+
+    A drawing can range from an empty drawing (i.e., no content inside of the drawing),
+    to a very simple drawing containing a single SVG element such as a *rect*,
+    to a complex, deeply nested collection of container elements and graphics elements.
+    """
+    def __init__(self, filename="noname.svg", size=('100%', '100%'), **extra):
+        """
+        :param string filename: filesystem filename valid for :func:`open`
+        :param 2-tuple size: width, height
+        :param keywords extra: additional svg-attributes for the *SVG* object
+
+        Important (and not SVG Attributes) **extra** parameters:
+
+        :param string profile: ``'tiny | full'`` - define the SVG baseProfile
+        :param bool debug: switch validation on/off
+
+        """
+        super(Drawing, self).__init__(size=size, **extra)
+        self.filename = filename
+        self._stylesheets = []  # list of stylesheets appended
+
+    def get_xml(self):
+        """ Get the XML representation as `ElementTree` object.
+
+        :return: XML `ElementTree` of this object and all its subelements
+
+        """
+        profile = self.profile
+        version = self.version
+        self.attribs['xmlns'] = "http://www.w3.org/2000/svg"
+        self.attribs['xmlns:xlink'] = "http://www.w3.org/1999/xlink"
+        self.attribs['xmlns:ev'] = "http://www.w3.org/2001/xml-events"
+
+        self.attribs['baseProfile'] = profile
+        self.attribs['version'] = version
+        return super(Drawing, self).get_xml()
+
+    def add_stylesheet(self, href, title, alternate="no", media="screen"):
+        """ Add a stylesheet reference.
+
+        :param string href: link to stylesheet <URI>
+        :param string title: name of stylesheet
+        :param string alternate: ``'yes'|'no'``
+        :param string media: ``'all | aureal | braille | embossed | handheld | print | projection | screen | tty | tv'``
+
+        """
+        self._stylesheets.append((href, title, alternate, media))
+
+    def write(self, fileobj, pretty=False, indent=2):
+        """ Write XML string to `fileobj`.
+
+        :param fileobj: a file-like object
+        :param pretty: True for easy readable output
+        :param indent: how much to indent if pretty is enabled, by default 2 spaces
+
+        Python 3.x - set encoding at the open command::
+
+            open('filename', 'w', encoding='utf-8')
+        """
+        # write xml header
+        fileobj.write('<?xml version="1.0" encoding="utf-8" ?>\n')
+
+        # don't use DOCTYPE. It's useless. see also:
+        # http://tech.groups.yahoo.com/group/svg-developers/message/48562
+        # write stylesheets
+        stylesheet_template = '<?xml-stylesheet href="%s" type="text/css" ' \
+            'title="%s" alternate="%s" media="%s"?>\n'
+        # removed map(), does not work with Python 3
+        for stylesheet in self._stylesheets:
+            fileobj.write(stylesheet_template % stylesheet)
+
+        xml_string = self.tostring()
+        if pretty:  # write easy readable XML file
+            xml_string = pretty_xml(xml_string, indent=indent)
+        fileobj.write(xml_string)
+
+    def save(self, pretty=False, indent=2):
+        """ Write the XML string to `self.filename`.
+
+        :param pretty: True for easy readable output
+        :param indent: how much to indent if pretty is enabled, by default 2 spaces
+        """
+        fileobj = io.open(self.filename, mode='w', encoding='utf-8')
+        self.write(fileobj, pretty=pretty, indent=indent)
+        fileobj.close()
+
+    def saveas(self, filename, pretty=False, indent=2):
+        """ Write the XML string to `filename`.
+
+        :param string filename: filesystem filename valid for :func:`open`
+        :param pretty: True for easy readable output
+        :param indent: how much to indent if pretty is enabled, by default 2 spaces
+        """
+        self.filename = filename
+        self.save(pretty=pretty, indent=indent)
+
+    def _repr_svg_(self):
+        """ Show SVG in IPython, Jupyter Notebook, and Jupyter Lab
+
+        :return: unicode XML string of this object and all its subelements
+
+        """
+        return self.tostring()

falcon/lib/python3.10/site-packages/svgwrite/etree.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+#coding:utf-8
+# Author:  mozman
+# Purpose: a hack to generate XML containing CDATA by ElementTree
+# Created: 26.05.2012
+# Copyright (C) 2012, Manfred Moitzi
+# License: MIT License
+
+# usage:
+#
+# from svgwrite.etree import etree, CDATA
+#
+# element = etree.Element('myTag')
+# element.append(CDATA("< and >"))
+#
+# assert etree.tostring(element) == "<myTag><![CDATA[< and >]]></myTag>"
+
+
+import sys
+PY3 = sys.version_info[0] > 2
+
+import xml.etree.ElementTree as etree
+
+CDATA_TPL = "<![CDATA[%s]]>"
+CDATA_TAG = CDATA_TPL
+
+
+def CDATA(text):
+    element = etree.Element(CDATA_TAG)
+    element.text = text
+    return element
+
+original_serialize_xml = etree._serialize_xml
+
+if PY3:
+    def _serialize_xml_with_CDATA_support(write, elem, qnames, namespaces, **kwargs):
+        if elem.tag == CDATA_TAG:
+            write(CDATA_TPL % elem.text)
+        else:
+            original_serialize_xml(write, elem, qnames, namespaces, **kwargs)
+else:
+    def _serialize_xml_with_CDATA_support(write, elem, encoding, qnames, namespaces):
+        if elem.tag == CDATA_TAG:
+            write(CDATA_TPL % elem.text.encode(encoding))
+        else:
+            original_serialize_xml(write, elem, encoding, qnames, namespaces)
+
+# ugly, ugly, ugly patching
+etree._serialize_xml = _serialize_xml_with_CDATA_support

falcon/lib/python3.10/site-packages/svgwrite/extensions/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2018 Manfred Moitzi
+# License: MIT License
+from .inkscape import Inkscape