test bkp

.documentation/lib/python3.12/site-packages/materialx/__init__.py

@@ -0,0 +1 @@
+"""MkDocs Material Extensions."""

.documentation/lib/python3.12/site-packages/materialx/__meta__.py

@@ -0,0 +1,192 @@
+"""Meta related things."""
+from collections import namedtuple
+import re
+
+RE_VER = re.compile(
+    r'''(?x)
+    (?P<major>\d+)(?:\.(?P<minor>\d+))?(?:\.(?P<micro>\d+))?
+    (?:(?P<type>a|b|rc)(?P<pre>\d+))?
+    (?:\.post(?P<post>\d+))?
+    (?:\.dev(?P<dev>\d+))?
+    '''
+)
+
+REL_MAP = {
+    ".dev": "",
+    ".dev-alpha": "a",
+    ".dev-beta": "b",
+    ".dev-candidate": "rc",
+    "alpha": "a",
+    "beta": "b",
+    "candidate": "rc",
+    "final": ""
+}
+
+DEV_STATUS = {
+    ".dev": "2 - Pre-Alpha",
+    ".dev-alpha": "2 - Pre-Alpha",
+    ".dev-beta": "2 - Pre-Alpha",
+    ".dev-candidate": "2 - Pre-Alpha",
+    "alpha": "3 - Alpha",
+    "beta": "4 - Beta",
+    "candidate": "4 - Beta",
+    "final": "5 - Production/Stable"
+}
+
+PRE_REL_MAP = {"a": 'alpha', "b": 'beta', "rc": 'candidate'}
+
+
+class Version(namedtuple("Version", ["major", "minor", "micro", "release", "pre", "post", "dev"])):
+    """
+    Get the version (PEP 440).
+
+    A biased approach to the PEP 440 semantic version.
+
+    Provides a tuple structure which is sorted for comparisons `v1 > v2` etc.
+      (major, minor, micro, release type, pre-release build, post-release build, development release build)
+    Release types are named in is such a way they are comparable with ease.
+    Accessors to check if a development, pre-release, or post-release build. Also provides accessor to get
+    development status for setup files.
+
+    How it works (currently):
+
+    - You must specify a release type as either `final`, `alpha`, `beta`, or `candidate`.
+    - To define a development release, you can use either `.dev`, `.dev-alpha`, `.dev-beta`, or `.dev-candidate`.
+      The dot is used to ensure all development specifiers are sorted before `alpha`.
+      You can specify a `dev` number for development builds, but do not have to as implicit development releases
+      are allowed.
+    - You must specify a `pre` value greater than zero if using a prerelease as this project (not PEP 440) does not
+      allow implicit prereleases.
+    - You can optionally set `post` to a value greater than zero to make the build a post release. While post releases
+      are technically allowed in prereleases, it is strongly discouraged, so we are rejecting them. It should be
+      noted that we do not allow `post0` even though PEP 440 does not restrict this. This project specifically
+      does not allow implicit post releases.
+    - It should be noted that we do not support epochs `1!` or local versions `+some-custom.version-1`.
+
+    Acceptable version releases:
+
+    ```
+    Version(1, 0, 0, "final")                    1.0
+    Version(1, 2, 0, "final")                    1.2
+    Version(1, 2, 3, "final")                    1.2.3
+    Version(1, 2, 0, "alpha", pre=4)             1.2a4
+    Version(1, 2, 0, "beta", pre=4)              1.2b4
+    Version(1, 2, 0, "candidate", pre=4)         1.2rc4
+    Version(1, 2, 0, "final", post=1)            1.2.post1
+    Version(1, 2, 3, ".dev")                     1.2.3.dev0
+    Version(1, 2, 3, ".dev", dev=1)              1.2.3.dev1
+    ```
+
+    """
+
+    def __new__(cls, major, minor, micro, release="final", pre=0, post=0, dev=0):
+        """Validate version info."""
+
+        # Ensure all parts are positive integers.
+        for value in (major, minor, micro, pre, post):
+            if not (isinstance(value, int) and value >= 0):
+                raise ValueError("All version parts except 'release' should be integers.")
+
+        if release not in REL_MAP:
+            raise ValueError("'{}' is not a valid release type.".format(release))
+
+        # Ensure valid pre-release (we do not allow implicit pre-releases).
+        if ".dev-candidate" < release < "final":
+            if pre == 0:
+                raise ValueError("Implicit pre-releases not allowed.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure valid development or development/pre release
+        elif release < "alpha":
+            if release > ".dev" and pre == 0:
+                raise ValueError("Implicit pre-release not allowed.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure a valid normal release
+        else:
+            if pre:
+                raise ValueError("Version is not a pre-release.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+
+        return super().__new__(cls, major, minor, micro, release, pre, post, dev)
+
+    def _is_pre(self):
+        """Is prerelease."""
+
+        return bool(self.pre > 0)
+
+    def _is_dev(self):
+        """Is development."""
+
+        return bool(self.release < "alpha")
+
+    def _is_post(self):
+        """Is post."""
+
+        return bool(self.post > 0)
+
+    def _get_dev_status(self):  # pragma: no cover
+        """Get development status string."""
+
+        return DEV_STATUS[self.release]
+
+    def _get_canonical(self):
+        """Get the canonical output string."""
+
+        # Assemble major, minor, micro version and append `pre`, `post`, or `dev` if needed..
+        if self.micro == 0 and self.major != 0:
+            ver = "{}.{}".format(self.major, self.minor)
+        else:
+            ver = "{}.{}.{}".format(self.major, self.minor, self.micro)
+        if self._is_pre():
+            ver += '{}{}'.format(REL_MAP[self.release], self.pre)
+        if self._is_post():
+            ver += ".post{}".format(self.post)
+        if self._is_dev():
+            ver += ".dev{}".format(self.dev)
+
+        return ver
+
+
+def parse_version(ver):
+    """Parse version into a comparable Version tuple."""
+
+    m = RE_VER.match(ver)
+
+    if m is None:
+        raise ValueError("'{}' is not a valid version".format(ver))
+
+    # Handle major, minor, micro
+    major = int(m.group('major'))
+    minor = int(m.group('minor')) if m.group('minor') else 0
+    micro = int(m.group('micro')) if m.group('micro') else 0
+
+    # Handle pre releases
+    if m.group('type'):
+        release = PRE_REL_MAP[m.group('type')]
+        pre = int(m.group('pre'))
+    else:
+        release = "final"
+        pre = 0
+
+    # Handle development releases
+    dev = m.group('dev') if m.group('dev') else 0
+    if m.group('dev'):
+        dev = int(m.group('dev'))
+        release = '.dev-' + release if pre else '.dev'
+    else:
+        dev = 0
+
+    # Handle post
+    post = int(m.group('post')) if m.group('post') else 0
+
+    return Version(major, minor, micro, release, pre, post, dev)
+
+
+__version_info__ = Version(1, 3, 1, "final")
+__version__ = __version_info__._get_canonical()

.documentation/lib/python3.12/site-packages/materialx/emoji.py

@@ -0,0 +1,162 @@
+"""
+Emoji extras for Material.
+
+Override the indexes with an extended version that includes short names for Material icons, FontAwesome, etc.
+"""
+import os
+import glob
+import copy
+import codecs
+import functools
+import inspect
+import material
+import pymdownx
+from pymdownx.emoji import TWEMOJI_SVG_CDN, add_attriubtes
+import xml.etree.ElementTree as etree  # noqa: N813
+import warnings
+from functools import wraps
+import logging
+
+log = logging.getLogger('mkdocs')
+
+DEPRECATED = """\
+Material emoji logic has been officially moved into mkdocs-material
+version 9.4. Please use Material's '{}'
+instead of '{}' in your 'mkdocs.yml' file.
+
+```
+markdown_extensions:
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+```
+
+'mkdocs_material_extensions' is deprecated and will no longer be
+supported moving forward. This is the last release.
+"""
+
+
+OPTION_SUPPORT = pymdownx.__version_info__ >= (7, 1, 0)
+RESOURCES = os.path.dirname(inspect.getfile(material))
+if os.path.exists(os.path.join(RESOURCES, 'templates', '.icons')):  # pragma: no cover
+    RES_PATH = os.path.join(RESOURCES, 'templates', '.icons')
+else:  # pragma: no cover
+    RES_PATH = os.path.join(RESOURCES, '.icons')
+
+
+@functools.lru_cache(maxsize=None)
+def log_msg(message):
+    """Log message."""
+
+    log.warning(message)
+
+
+def deprecated(message, stacklevel=2, name=None):  # pragma: no cover
+    """
+    Raise a `DeprecationWarning` when wrapped function/method is called.
+
+    Usage:
+
+        @deprecated("This method will be removed in version X; use Y instead.")
+        def some_method()"
+            pass
+    """
+
+    def _wrapper(func):
+        @wraps(func)
+        def _deprecated_func(*args, **kwargs):
+            warnings.warn(
+                f"'{func.__name__ if name is None else name}' is deprecated.\n{message}",
+                category=DeprecationWarning,
+                stacklevel=stacklevel
+            )
+
+            log_msg(message)
+            return func(*args, **kwargs)
+        return _deprecated_func
+    return _wrapper
+
+
+@deprecated(
+    DEPRECATED.format('material.extensions.emoji.twemoji', 'materialx.emoji.twemoji'),
+    name='materialx.emoji.twemoji'
+)
+def _patch_index(options):
+    """Patch the given index."""
+
+    icon_locations = options.get('custom_icons', [])[:]
+    icon_locations.append(RES_PATH)
+    return _patch_index_for_locations(tuple(icon_locations))
+
+
+@functools.lru_cache(maxsize=None)
+def _patch_index_for_locations(icon_locations):
+    import pymdownx.twemoji_db as twemoji_db
+
+    # Copy the Twemoji index
+    index = {
+        "name": 'twemoji',
+        "emoji": copy.deepcopy(twemoji_db.emoji) if not OPTION_SUPPORT else twemoji_db.emoji,
+        "aliases": copy.deepcopy(twemoji_db.aliases) if not OPTION_SUPPORT else twemoji_db.aliases
+    }
+
+    # Find our icons
+    for icon_path in icon_locations:
+        norm_base = icon_path.replace('\\', '/') + '/'
+        for result in glob.glob(glob.escape(icon_path.replace('\\', '/')) + '/**/*.svg', recursive=True):
+            name = ':{}:'.format(result.replace('\\', '/').replace(norm_base, '', 1).replace('/', '-').lstrip('.')[:-4])
+            if name not in index['emoji'] and name not in index['aliases']:
+                # Easiest to just store the path and pull it out from the index
+                index["emoji"][name] = {'name': name, 'path': result}
+    return index
+
+
+if OPTION_SUPPORT:  # pragma: no cover
+    def twemoji(options, md):
+        """Provide a copied Twemoji index with additional codes for Material included icons."""
+
+        return _patch_index(options)
+
+else:  # pragma: no cover
+    def twemoji():
+        """Provide a copied Twemoji index with additional codes for Material included icons."""
+
+        return _patch_index({})
+
+
+@deprecated(
+    DEPRECATED.format('material.extensions.emoji.to_svg', 'materialx.emoji.to_svg'),
+    1,
+    name='materialx.emoji.to_svg'
+)
+def to_svg(index, shortname, alias, uc, alt, title, category, options, md):
+    """Return SVG element."""
+
+    is_unicode = uc is not None
+
+    if is_unicode:
+        # Handle Twemoji emoji.
+        svg_path = TWEMOJI_SVG_CDN
+
+        attributes = {
+            "class": options.get('classes', index),
+            "alt": alt,
+            "src": "%s%s.svg" % (
+                options.get('image_path', svg_path),
+                uc
+            )
+        }
+
+        if title:
+            attributes['title'] = title
+
+        add_attriubtes(options, attributes)
+
+        return etree.Element("img", attributes)
+    else:
+        # Handle Material SVG assets.
+        el = etree.Element('span', {"class": options.get('classes', index)})
+        svg_path = md.inlinePatterns['emoji'].emoji_index['emoji'][shortname]['path']
+        with codecs.open(svg_path, 'r', encoding='utf-8') as f:
+            el.text = md.htmlStash.store(f.read())
+        return el