Add files using upload-large-folder tool

rtme/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

rtme/bin/accelerate

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.accelerate_cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/accelerate-config

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.config import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/accelerate-estimate-memory

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.estimate import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/accelerate-launch

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from accelerate.commands.launch import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/activate

@@ -0,0 +1,116 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+# Get script path (only used if environment is relocatable).
+if [ -n "${BASH_VERSION:+x}" ] ; then
+    SCRIPT_PATH="${BASH_SOURCE[0]}"
+    if [ "$SCRIPT_PATH" = "$0" ]; then
+        # Only bash has a reasonably robust check for source'dness.
+        echo "You must source this script: \$ source $0" >&2
+        exit 33
+    fi
+elif [ -n "${ZSH_VERSION:+x}" ] ; then
+    SCRIPT_PATH="${(%):-%x}"
+elif [ -n "${KSH_VERSION:+x}" ] ; then
+    SCRIPT_PATH="${.sh.file}"
+fi
+
+deactivate () {
+    unset -f pydoc >/dev/null 2>&1 || true
+
+    # reset old environment variables
+    # ! [ -z ${VAR+_} ] returns true if VAR is declared at all
+    if ! [ -z "${_OLD_VIRTUAL_PATH:+_}" ] ; then
+        PATH="$_OLD_VIRTUAL_PATH"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then
+        PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # The hash command must be called to get it to forget past
+    # commands. Without forgetting past commands the $PATH changes
+    # we made may not be respected
+    hash -r 2>/dev/null
+
+    if ! [ -z "${_OLD_VIRTUAL_PS1+_}" ] ; then
+        PS1="$_OLD_VIRTUAL_PS1"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV='/workspace/rtme'
+if ([ "$OSTYPE" = "cygwin" ] || [ "$OSTYPE" = "msys" ]) && $(command -v cygpath &> /dev/null) ; then
+    VIRTUAL_ENV=$(cygpath -u "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+if [ "x" != x ] ; then
+    VIRTUAL_ENV_PROMPT="() "
+else
+    VIRTUAL_ENV_PROMPT="($(basename "$VIRTUAL_ENV")) "
+fi
+export VIRTUAL_ENV_PROMPT
+
+# unset PYTHONHOME if set
+if ! [ -z "${PYTHONHOME+_}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1-}"
+    PS1="${VIRTUAL_ENV_PROMPT}${PS1-}"
+    export PS1
+fi
+
+# Make sure to unalias pydoc if it's already there
+alias pydoc 2>/dev/null >/dev/null && unalias pydoc || true
+
+pydoc () {
+    python -m pydoc "$@"
+}
+
+# The hash command must be called to get it to forget past
+# commands. Without forgetting past commands the $PATH changes
+# we made may not be respected
+hash -r 2>/dev/null

rtme/bin/activate.bat

@@ -0,0 +1,71 @@
+@REM Copyright (c) 2020-202x The virtualenv developers
+@REM
+@REM Permission is hereby granted, free of charge, to any person obtaining
+@REM a copy of this software and associated documentation files (the
+@REM "Software"), to deal in the Software without restriction, including
+@REM without limitation the rights to use, copy, modify, merge, publish,
+@REM distribute, sublicense, and/or sell copies of the Software, and to
+@REM permit persons to whom the Software is furnished to do so, subject to
+@REM the following conditions:
+@REM
+@REM The above copyright notice and this permission notice shall be
+@REM included in all copies or substantial portions of the Software.
+@REM
+@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+@REM This file is UTF-8 encoded, so we need to update the current code page while executing it
+@for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do @set _OLD_CODEPAGE=%%a
+@if defined _OLD_CODEPAGE (
+    @"%SystemRoot%\System32\chcp.com" 65001 > nul
+)
+
+@for %%i in ("/workspace/rtme") do @set "VIRTUAL_ENV=%%~fi"
+
+@set "VIRTUAL_ENV_PROMPT="
+@if NOT DEFINED VIRTUAL_ENV_PROMPT (
+    @for %%d in ("%VIRTUAL_ENV%") do @set "VIRTUAL_ENV_PROMPT=%%~nxd"
+)
+
+@if defined _OLD_VIRTUAL_PROMPT (
+    @set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+) else (
+    @if not defined PROMPT (
+        @set "PROMPT=$P$G"
+    )
+    @if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+        @set "_OLD_VIRTUAL_PROMPT=%PROMPT%"
+    )
+)
+@if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+    @set "PROMPT=(%VIRTUAL_ENV_PROMPT%) %PROMPT%"
+)
+
+@REM Don't use () to avoid problems with them in %PATH%
+@if defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME
+    @set "_OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%"
+:ENDIFVHOME
+
+@set PYTHONHOME=
+
+@REM if defined _OLD_VIRTUAL_PATH (
+@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH1
+    @set "PATH=%_OLD_VIRTUAL_PATH%"
+:ENDIFVPATH1
+@REM ) else (
+@if defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH2
+    @set "_OLD_VIRTUAL_PATH=%PATH%"
+:ENDIFVPATH2
+
+@set "PATH=%VIRTUAL_ENV%\bin;%PATH%"
+
+:END
+@if defined _OLD_CODEPAGE (
+    @"%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul
+    @set _OLD_CODEPAGE=
+)

rtme/bin/activate.csh

@@ -0,0 +1,76 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+
+set newline='\
+'
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH:q" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT:q" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV '/workspace/rtme'
+
+set _OLD_VIRTUAL_PATH="$PATH:q"
+setenv PATH "$VIRTUAL_ENV:q/bin:$PATH:q"
+
+
+
+if ('' != "") then
+    setenv VIRTUAL_ENV_PROMPT ''
+else
+    setenv VIRTUAL_ENV_PROMPT "$VIRTUAL_ENV:t:q"
+endif
+
+if ( $?VIRTUAL_ENV_DISABLE_PROMPT ) then
+    if ( $VIRTUAL_ENV_DISABLE_PROMPT == "" ) then
+        set do_prompt = "1"
+    else
+        set do_prompt = "0"
+    endif
+else
+    set do_prompt = "1"
+endif
+
+if ( $do_prompt == "1" ) then
+    # Could be in a non-interactive environment,
+    # in which case, $prompt is undefined and we wouldn't
+    # care about the prompt anyway.
+    if ( $?prompt ) then
+        set _OLD_VIRTUAL_PROMPT="$prompt:q"
+        if ( "$prompt:q" =~ *"$newline:q"* ) then
+            :
+        else
+            set prompt = '('"$VIRTUAL_ENV_PROMPT:q"') '"$prompt:q"
+        endif
+    endif
+endif
+
+unset env_name
+unset do_prompt
+
+alias pydoc python -m pydoc
+
+rehash

rtme/bin/activate.nu

@@ -0,0 +1,117 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# virtualenv activation module
+# Activate with `overlay use activate.nu`
+# Deactivate with `deactivate`, as usual
+#
+# To customize the overlay name, you can call `overlay use activate.nu as foo`,
+# but then simply `deactivate` won't work because it is just an alias to hide
+# the "activate" overlay. You'd need to call `overlay hide foo` manually.
+
+export-env {
+    def is-string [x] {
+        ($x | describe) == 'string'
+    }
+
+    def has-env [...names] {
+        $names | each {|n|
+            $n in $env
+        } | all {|i| $i == true}
+    }
+
+    # Emulates a `test -z`, but better as it handles e.g 'false'
+    def is-env-true [name: string] {
+      if (has-env $name) {
+        # Try to parse 'true', '0', '1', and fail if not convertible
+        let parsed = (do -i { $env | get $name | into bool })
+        if ($parsed | describe) == 'bool' {
+          $parsed
+        } else {
+          not ($env | get -i $name | is-empty)
+        }
+      } else {
+        false
+      }
+    }
+
+    let virtual_env = '/workspace/rtme'
+    let bin = 'bin'
+
+    let is_windows = ($nu.os-info.family) == 'windows'
+    let path_name = (if (has-env 'Path') {
+            'Path'
+        } else {
+            'PATH'
+        }
+    )
+
+    let venv_path = ([$virtual_env $bin] | path join)
+    let new_path = ($env | get $path_name | prepend $venv_path)
+
+    # If there is no default prompt, then use the env name instead
+    let virtual_env_prompt = (if ('' | is-empty) {
+        ($virtual_env | path basename)
+    } else {
+        ''
+    })
+
+    let new_env = {
+        $path_name         : $new_path
+        VIRTUAL_ENV        : $virtual_env
+        VIRTUAL_ENV_PROMPT : $virtual_env_prompt
+    }
+
+    let new_env = (if (is-env-true 'VIRTUAL_ENV_DISABLE_PROMPT') {
+      $new_env
+    } else {
+      # Creating the new prompt for the session
+      let virtual_prefix = $'(char lparen)($virtual_env_prompt)(char rparen) '
+
+      # Back up the old prompt builder
+      let old_prompt_command = (if (has-env 'PROMPT_COMMAND') {
+              $env.PROMPT_COMMAND
+          } else {
+              ''
+        })
+
+      let new_prompt = (if (has-env 'PROMPT_COMMAND') {
+          if 'closure' in ($old_prompt_command | describe) {
+              {|| $'($virtual_prefix)(do $old_prompt_command)' }
+          } else {
+              {|| $'($virtual_prefix)($old_prompt_command)' }
+          }
+      } else {
+          {|| $'($virtual_prefix)' }
+      })
+
+      $new_env | merge {
+        PROMPT_COMMAND      : $new_prompt
+        VIRTUAL_PREFIX      : $virtual_prefix
+      }
+    })
+
+    # Environment variables that will be loaded as the virtual env
+    load-env $new_env
+}
+
+export alias pydoc = python -m pydoc
+export alias deactivate = overlay hide activate

rtme/bin/activate.ps1

@@ -0,0 +1,82 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+$script:THIS_PATH = $myinvocation.mycommand.path
+$script:BASE_DIR = Split-Path (Resolve-Path "$THIS_PATH/..") -Parent
+
+function global:deactivate([switch] $NonDestructive) {
+    if (Test-Path variable:_OLD_VIRTUAL_PATH) {
+        $env:PATH = $variable:_OLD_VIRTUAL_PATH
+        Remove-Variable "_OLD_VIRTUAL_PATH" -Scope global
+    }
+
+    if (Test-Path function:_old_virtual_prompt) {
+        $function:prompt = $function:_old_virtual_prompt
+        Remove-Item function:\_old_virtual_prompt
+    }
+
+    if ($env:VIRTUAL_ENV) {
+        Remove-Item env:VIRTUAL_ENV -ErrorAction SilentlyContinue
+    }
+
+    if ($env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item env:VIRTUAL_ENV_PROMPT -ErrorAction SilentlyContinue
+    }
+
+    if (!$NonDestructive) {
+        # Self destruct!
+        Remove-Item function:deactivate
+        Remove-Item function:pydoc
+    }
+}
+
+function global:pydoc {
+    python -m pydoc $args
+}
+
+# unset irrelevant variables
+deactivate -nondestructive
+
+$VIRTUAL_ENV = $BASE_DIR
+$env:VIRTUAL_ENV = $VIRTUAL_ENV
+
+if ("" -ne "") {
+    $env:VIRTUAL_ENV_PROMPT = ""
+}
+else {
+    $env:VIRTUAL_ENV_PROMPT = $( Split-Path $env:VIRTUAL_ENV -Leaf )
+}
+
+New-Variable -Scope global -Name _OLD_VIRTUAL_PATH -Value $env:PATH
+
+$env:PATH = "$env:VIRTUAL_ENV/bin:" + $env:PATH
+if (!$env:VIRTUAL_ENV_DISABLE_PROMPT) {
+    function global:_old_virtual_prompt {
+        ""
+    }
+    $function:_old_virtual_prompt = $function:prompt
+
+    function global:prompt {
+        # Add the custom prefix to the existing prompt
+        $previous_prompt_value = & $function:_old_virtual_prompt
+        ("(" + $env:VIRTUAL_ENV_PROMPT + ") " + $previous_prompt_value)
+    }
+}

rtme/bin/activate_this.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.10/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

rtme/bin/convert-caffe2-to-onnx

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from caffe2.python.onnx.bin.conversion import caffe2_to_onnx
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(caffe2_to_onnx())

rtme/bin/deactivate.bat

@@ -0,0 +1,39 @@
+@REM Copyright (c) 2020-202x The virtualenv developers
+@REM
+@REM Permission is hereby granted, free of charge, to any person obtaining
+@REM a copy of this software and associated documentation files (the
+@REM "Software"), to deal in the Software without restriction, including
+@REM without limitation the rights to use, copy, modify, merge, publish,
+@REM distribute, sublicense, and/or sell copies of the Software, and to
+@REM permit persons to whom the Software is furnished to do so, subject to
+@REM the following conditions:
+@REM
+@REM The above copyright notice and this permission notice shall be
+@REM included in all copies or substantial portions of the Software.
+@REM
+@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+@set VIRTUAL_ENV=
+@set VIRTUAL_ENV_PROMPT=
+
+@REM Don't use () to avoid problems with them in %PATH%
+@if not defined _OLD_VIRTUAL_PROMPT @goto ENDIFVPROMPT
+    @set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+    @set _OLD_VIRTUAL_PROMPT=
+:ENDIFVPROMPT
+
+@if not defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME
+    @set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%"
+    @set _OLD_VIRTUAL_PYTHONHOME=
+:ENDIFVHOME
+
+@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH
+    @set "PATH=%_OLD_VIRTUAL_PATH%"
+    @set _OLD_VIRTUAL_PATH=
+:ENDIFVPATH

rtme/bin/debugpy

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from debugpy.server.cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/diffusers-cli

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from diffusers.commands.diffusers_cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/f2py

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/fonttools

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from fontTools.__main__ import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/huggingface-cli

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from huggingface_hub.commands.huggingface_cli import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/nib-roi

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from nibabel.cmdline.roi import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/nib-stats

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from nibabel.cmdline.stats import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/pybabel

@@ -0,0 +1,10 @@
+#!/workspace/rtme/bin/python3
+# -*- coding: utf-8 -*-
+import sys
+from babel.messages.frontend import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

rtme/bin/pydoc.bat

@@ -0,0 +1,22 @@
+@REM Copyright (c) 2020-202x The virtualenv developers
+@REM
+@REM Permission is hereby granted, free of charge, to any person obtaining
+@REM a copy of this software and associated documentation files (the
+@REM "Software"), to deal in the Software without restriction, including
+@REM without limitation the rights to use, copy, modify, merge, publish,
+@REM distribute, sublicense, and/or sell copies of the Software, and to
+@REM permit persons to whom the Software is furnished to do so, subject to
+@REM the following conditions:
+@REM
+@REM The above copyright notice and this permission notice shall be
+@REM included in all copies or substantial portions of the Software.
+@REM
+@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+python.exe -m pydoc %*

rtme/lib/python3.10/site-packages/babel/__init__.py

@@ -0,0 +1,38 @@
+"""
+    babel
+    ~~~~~
+
+    Integrated collection of utilities that assist in internationalizing and
+    localizing applications.
+
+    This package is basically composed of two major parts:
+
+     * tools to build and work with ``gettext`` message catalogs
+     * a Python interface to the CLDR (Common Locale Data Repository), providing
+       access to various locale display names, localized number and date
+       formatting, etc.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from babel.core import (
+    Locale,
+    UnknownLocaleError,
+    default_locale,
+    get_locale_identifier,
+    negotiate_locale,
+    parse_locale,
+)
+
+__version__ = '2.17.0'
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    '__version__',
+    'default_locale',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]

rtme/lib/python3.10/site-packages/babel/core.py

@@ -0,0 +1,1337 @@
+"""
+    babel.core
+    ~~~~~~~~~~
+
+    Core locale representation and locale data access.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING, Any, Literal
+
+from babel import localedata
+from babel.plural import PluralRule
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    'default_locale',
+    'get_global',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    _GLOBAL_KEY: TypeAlias = Literal[
+        "all_currencies",
+        "currency_fractions",
+        "language_aliases",
+        "likely_subtags",
+        "meta_zones",
+        "parent_exceptions",
+        "script_aliases",
+        "territory_aliases",
+        "territory_currencies",
+        "territory_languages",
+        "territory_zones",
+        "variant_aliases",
+        "windows_zone_mapping",
+        "zone_aliases",
+        "zone_territories",
+    ]
+
+    _global_data: Mapping[_GLOBAL_KEY, Mapping[str, Any]] | None
+
+_global_data = None
+_default_plural_rule = PluralRule({})
+
+
+def _raise_no_data_error():
+    raise RuntimeError('The babel data files are not available. '
+                       'This usually happens because you are using '
+                       'a source checkout from Babel and you did '
+                       'not build the data files.  Just make sure '
+                       'to run "python setup.py import_cldr" before '
+                       'installing the library.')
+
+
+def get_global(key: _GLOBAL_KEY) -> Mapping[str, Any]:
+    """Return the dictionary for the given key in the global data.
+
+    The global data is stored in the ``babel/global.dat`` file and contains
+    information independent of individual locales.
+
+    >>> get_global('zone_aliases')['UTC']
+    u'Etc/UTC'
+    >>> get_global('zone_territories')['Europe/Berlin']
+    u'DE'
+
+    The keys available are:
+
+    - ``all_currencies``
+    - ``currency_fractions``
+    - ``language_aliases``
+    - ``likely_subtags``
+    - ``parent_exceptions``
+    - ``script_aliases``
+    - ``territory_aliases``
+    - ``territory_currencies``
+    - ``territory_languages``
+    - ``territory_zones``
+    - ``variant_aliases``
+    - ``windows_zone_mapping``
+    - ``zone_aliases``
+    - ``zone_territories``
+
+    .. note:: The internal structure of the data may change between versions.
+
+    .. versionadded:: 0.9
+
+    :param key: the data key
+    """
+    global _global_data
+    if _global_data is None:
+        dirname = os.path.join(os.path.dirname(__file__))
+        filename = os.path.join(dirname, 'global.dat')
+        if not os.path.isfile(filename):
+            _raise_no_data_error()
+        with open(filename, 'rb') as fileobj:
+            _global_data = pickle.load(fileobj)
+            assert _global_data is not None
+    return _global_data.get(key, {})
+
+
+LOCALE_ALIASES = {
+    'ar': 'ar_SY', 'bg': 'bg_BG', 'bs': 'bs_BA', 'ca': 'ca_ES', 'cs': 'cs_CZ',
+    'da': 'da_DK', 'de': 'de_DE', 'el': 'el_GR', 'en': 'en_US', 'es': 'es_ES',
+    'et': 'et_EE', 'fa': 'fa_IR', 'fi': 'fi_FI', 'fr': 'fr_FR', 'gl': 'gl_ES',
+    'he': 'he_IL', 'hu': 'hu_HU', 'id': 'id_ID', 'is': 'is_IS', 'it': 'it_IT',
+    'ja': 'ja_JP', 'km': 'km_KH', 'ko': 'ko_KR', 'lt': 'lt_LT', 'lv': 'lv_LV',
+    'mk': 'mk_MK', 'nl': 'nl_NL', 'nn': 'nn_NO', 'no': 'nb_NO', 'pl': 'pl_PL',
+    'pt': 'pt_PT', 'ro': 'ro_RO', 'ru': 'ru_RU', 'sk': 'sk_SK', 'sl': 'sl_SI',
+    'sv': 'sv_SE', 'th': 'th_TH', 'tr': 'tr_TR', 'uk': 'uk_UA',
+}
+
+
+class UnknownLocaleError(Exception):
+    """Exception thrown when a locale is requested for which no locale data
+    is available.
+    """
+
+    def __init__(self, identifier: str) -> None:
+        """Create the exception.
+
+        :param identifier: the identifier string of the unsupported locale
+        """
+        Exception.__init__(self, f"unknown locale {identifier!r}")
+
+        #: The identifier of the locale that could not be found.
+        self.identifier = identifier
+
+
+class Locale:
+    """Representation of a specific locale.
+
+    >>> locale = Locale('en', 'US')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+    >>> locale.display_name
+    u'English (United States)'
+
+    A `Locale` object can also be instantiated from a raw locale string:
+
+    >>> locale = Locale.parse('en-US', sep='-')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+
+    `Locale` objects provide access to a collection of locale data, such as
+    territory and language names, number and date format patterns, and more:
+
+    >>> locale.number_symbols['latn']['decimal']
+    u'.'
+
+    If a locale is requested for which no locale data is available, an
+    `UnknownLocaleError` is raised:
+
+    >>> Locale.parse('en_XX')
+    Traceback (most recent call last):
+        ...
+    UnknownLocaleError: unknown locale 'en_XX'
+
+    For more information see :rfc:`3066`.
+    """
+
+    def __init__(
+        self,
+        language: str,
+        territory: str | None = None,
+        script: str | None = None,
+        variant: str | None = None,
+        modifier: str | None = None,
+    ) -> None:
+        """Initialize the locale object from the given identifier components.
+
+        >>> locale = Locale('en', 'US')
+        >>> locale.language
+        'en'
+        >>> locale.territory
+        'US'
+
+        :param language: the language code
+        :param territory: the territory (country or region) code
+        :param script: the script code
+        :param variant: the variant code
+        :param modifier: a modifier (following the '@' symbol, sometimes called '@variant')
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        """
+        #: the language code
+        self.language = language
+        #: the territory (country or region) code
+        self.territory = territory
+        #: the script code
+        self.script = script
+        #: the variant code
+        self.variant = variant
+        #: the modifier
+        self.modifier = modifier
+        self.__data: localedata.LocaleDataDict | None = None
+
+        identifier = str(self)
+        identifier_without_modifier = identifier.partition('@')[0]
+        if localedata.exists(identifier):
+            self.__data_identifier = identifier
+        elif localedata.exists(identifier_without_modifier):
+            self.__data_identifier = identifier_without_modifier
+        else:
+            raise UnknownLocaleError(identifier)
+
+    @classmethod
+    def default(cls, category: str | None = None, aliases: Mapping[str, str] = LOCALE_ALIASES) -> Locale:
+        """Return the system default locale for the specified category.
+
+        >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES']:
+        ...     os.environ[name] = ''
+        >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+        >>> Locale.default('LC_MESSAGES')
+        Locale('fr', territory='FR')
+
+        The following fallbacks to the variable are always considered:
+
+        - ``LANGUAGE``
+        - ``LC_ALL``
+        - ``LC_CTYPE``
+        - ``LANG``
+
+        :param category: one of the ``LC_XXX`` environment variable names
+        :param aliases: a dictionary of aliases for locale identifiers
+        """
+        # XXX: use likely subtag expansion here instead of the
+        # aliases dictionary.
+        locale_string = default_locale(category, aliases=aliases)
+        return cls.parse(locale_string)
+
+    @classmethod
+    def negotiate(
+        cls,
+        preferred: Iterable[str],
+        available: Iterable[str],
+        sep: str = '_',
+        aliases: Mapping[str, str] = LOCALE_ALIASES,
+    ) -> Locale | None:
+        """Find the best match between available and requested locale strings.
+
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+        Locale('de', territory='DE')
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['en', 'de'])
+        Locale('de')
+        >>> Locale.negotiate(['de_DE', 'de'], ['en_US'])
+
+        You can specify the character used in the locale identifiers to separate
+        the different components. This separator is applied to both lists. Also,
+        case is ignored in the comparison:
+
+        >>> Locale.negotiate(['de-DE', 'de'], ['en-us', 'de-de'], sep='-')
+        Locale('de', territory='DE')
+
+        :param preferred: the list of locale identifiers preferred by the user
+        :param available: the list of locale identifiers available
+        :param aliases: a dictionary of aliases for locale identifiers
+        :param sep: separator for parsing; e.g. Windows tends to use '-' instead of '_'.
+        """
+        identifier = negotiate_locale(preferred, available, sep=sep,
+                                      aliases=aliases)
+        if identifier:
+            return Locale.parse(identifier, sep=sep)
+        return None
+
+    @classmethod
+    def parse(
+        cls,
+        identifier: Locale | str | None,
+        sep: str = '_',
+        resolve_likely_subtags: bool = True,
+    ) -> Locale:
+        """Create a `Locale` instance for the given locale identifier.
+
+        >>> l = Locale.parse('de-DE', sep='-')
+        >>> l.display_name
+        u'Deutsch (Deutschland)'
+
+        If the `identifier` parameter is not a string, but actually a `Locale`
+        object, that object is returned:
+
+        >>> Locale.parse(l)
+        Locale('de', territory='DE')
+
+        If the `identifier` parameter is neither of these, such as `None`
+        or an empty string, e.g. because a default locale identifier
+        could not be determined, a `TypeError` is raised:
+
+        >>> Locale.parse(None)
+        Traceback (most recent call last):
+            ...
+        TypeError: ...
+
+        This also can perform resolving of likely subtags which it does
+        by default.  This is for instance useful to figure out the most
+        likely locale for a territory you can use ``'und'`` as the
+        language tag:
+
+        >>> Locale.parse('und_AT')
+        Locale('de', territory='AT')
+
+        Modifiers are optional, and always at the end, separated by "@":
+
+        >>> Locale.parse('de_AT@euro')
+        Locale('de', territory='AT', modifier='euro')
+
+        :param identifier: the locale identifier string
+        :param sep: optional component separator
+        :param resolve_likely_subtags: if this is specified then a locale will
+                                       have its likely subtag resolved if the
+                                       locale otherwise does not exist.  For
+                                       instance ``zh_TW`` by itself is not a
+                                       locale that exists but Babel can
+                                       automatically expand it to the full
+                                       form of ``zh_hant_TW``.  Note that this
+                                       expansion is only taking place if no
+                                       locale exists otherwise.  For instance
+                                       there is a locale ``en`` that can exist
+                                       by itself.
+        :raise `ValueError`: if the string does not appear to be a valid locale
+                             identifier
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        :raise `TypeError`: if the identifier is not a string or a `Locale`
+        :raise `ValueError`: if the identifier is not a valid string
+        """
+        if isinstance(identifier, Locale):
+            return identifier
+
+        if not identifier:
+            msg = (
+                f"Empty locale identifier value: {identifier!r}\n\n"
+                f"If you didn't explicitly pass an empty value to a Babel function, "
+                f"this could be caused by there being no suitable locale environment "
+                f"variables for the API you tried to use.",
+            )
+            if isinstance(identifier, str):
+                raise ValueError(msg)  # `parse_locale` would raise a ValueError, so let's do that here
+            raise TypeError(msg)
+
+        if not isinstance(identifier, str):
+            raise TypeError(f"Unexpected value for identifier: {identifier!r}")
+
+        parts = parse_locale(identifier, sep=sep)
+        input_id = get_locale_identifier(parts)
+
+        def _try_load(parts):
+            try:
+                return cls(*parts)
+            except UnknownLocaleError:
+                return None
+
+        def _try_load_reducing(parts):
+            # Success on first hit, return it.
+            locale = _try_load(parts)
+            if locale is not None:
+                return locale
+
+            # Now try without script and variant
+            locale = _try_load(parts[:2])
+            if locale is not None:
+                return locale
+
+        locale = _try_load(parts)
+        if locale is not None:
+            return locale
+        if not resolve_likely_subtags:
+            raise UnknownLocaleError(input_id)
+
+        # From here onwards is some very bad likely subtag resolving.  This
+        # whole logic is not entirely correct but good enough (tm) for the
+        # time being.  This has been added so that zh_TW does not cause
+        # errors for people when they upgrade.  Later we should properly
+        # implement ICU like fuzzy locale objects and provide a way to
+        # maximize and minimize locale tags.
+
+        if len(parts) == 5:
+            language, territory, script, variant, modifier = parts
+        else:
+            language, territory, script, variant = parts
+            modifier = None
+        language = get_global('language_aliases').get(language, language)
+        territory = get_global('territory_aliases').get(territory or '', (territory,))[0]
+        script = get_global('script_aliases').get(script or '', script)
+        variant = get_global('variant_aliases').get(variant or '', variant)
+
+        if territory == 'ZZ':
+            territory = None
+        if script == 'Zzzz':
+            script = None
+
+        parts = language, territory, script, variant, modifier
+
+        # First match: try the whole identifier
+        new_id = get_locale_identifier(parts)
+        likely_subtag = get_global('likely_subtags').get(new_id)
+        if likely_subtag is not None:
+            locale = _try_load_reducing(parse_locale(likely_subtag))
+            if locale is not None:
+                return locale
+
+        # If we did not find anything so far, try again with a
+        # simplified identifier that is just the language
+        likely_subtag = get_global('likely_subtags').get(language)
+        if likely_subtag is not None:
+            parts2 = parse_locale(likely_subtag)
+            if len(parts2) == 5:
+                language2, _, script2, variant2, modifier2 = parts2
+            else:
+                language2, _, script2, variant2 = parts2
+                modifier2 = None
+            locale = _try_load_reducing((language2, territory, script2, variant2, modifier2))
+            if locale is not None:
+                return locale
+
+        raise UnknownLocaleError(input_id)
+
+    def __eq__(self, other: object) -> bool:
+        for key in ('language', 'territory', 'script', 'variant', 'modifier'):
+            if not hasattr(other, key):
+                return False
+        return (
+            self.language == getattr(other, 'language') and  # noqa: B009
+            self.territory == getattr(other, 'territory') and  # noqa: B009
+            self.script == getattr(other, 'script') and  # noqa: B009
+            self.variant == getattr(other, 'variant') and  # noqa: B009
+            self.modifier == getattr(other, 'modifier')  # noqa: B009
+        )
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.language, self.territory, self.script,
+                     self.variant, self.modifier))
+
+    def __repr__(self) -> str:
+        parameters = ['']
+        for key in ('territory', 'script', 'variant', 'modifier'):
+            value = getattr(self, key)
+            if value is not None:
+                parameters.append(f"{key}={value!r}")
+        return f"Locale({self.language!r}{', '.join(parameters)})"
+
+    def __str__(self) -> str:
+        return get_locale_identifier((self.language, self.territory,
+                                      self.script, self.variant,
+                                      self.modifier))
+
+    @property
+    def _data(self) -> localedata.LocaleDataDict:
+        if self.__data is None:
+            self.__data = localedata.LocaleDataDict(localedata.load(self.__data_identifier))
+        return self.__data
+
+    def get_display_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the display name of the locale using the given locale.
+
+        The display name will include the language, territory, script, and
+        variant, if those are specified.
+
+        >>> Locale('zh', 'CN', script='Hans').get_display_name('en')
+        u'Chinese (Simplified, China)'
+
+        Modifiers are currently passed through verbatim:
+
+        >>> Locale('it', 'IT', modifier='euro').get_display_name('en')
+        u'Italian (Italy, euro)'
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        retval = locale.languages.get(self.language)
+        if retval and (self.territory or self.script or self.variant):
+            details = []
+            if self.script:
+                details.append(locale.scripts.get(self.script))
+            if self.territory:
+                details.append(locale.territories.get(self.territory))
+            if self.variant:
+                details.append(locale.variants.get(self.variant))
+            if self.modifier:
+                details.append(self.modifier)
+            detail_string = ', '.join(atom for atom in details if atom)
+            if detail_string:
+                retval += f" ({detail_string})"
+        return retval
+
+    display_name = property(get_display_name, doc="""\
+        The localized display name of the locale.
+
+        >>> Locale('en').display_name
+        u'English'
+        >>> Locale('en', 'US').display_name
+        u'English (United States)'
+        >>> Locale('sv').display_name
+        u'svenska'
+
+        :type: `unicode`
+        """)
+
+    def get_language_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the language of this locale in the given locale.
+
+        >>> Locale('zh', 'CN', script='Hans').get_language_name('de')
+        u'Chinesisch'
+
+        .. versionadded:: 1.0
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.languages.get(self.language)
+
+    language_name = property(get_language_name, doc="""\
+        The localized language name of the locale.
+
+        >>> Locale('en', 'US').language_name
+        u'English'
+    """)
+
+    def get_territory_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the territory name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.territories.get(self.territory or '')
+
+    territory_name = property(get_territory_name, doc="""\
+        The localized territory name of the locale if available.
+
+        >>> Locale('de', 'DE').territory_name
+        u'Deutschland'
+    """)
+
+    def get_script_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the script name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.scripts.get(self.script or '')
+
+    script_name = property(get_script_name, doc="""\
+        The localized script name of the locale if available.
+
+        >>> Locale('sr', 'ME', script='Latn').script_name
+        u'latinica'
+    """)
+
+    @property
+    def english_name(self) -> str | None:
+        """The english display name of the locale.
+
+        >>> Locale('de').english_name
+        u'German'
+        >>> Locale('de', 'DE').english_name
+        u'German (Germany)'
+
+        :type: `unicode`"""
+        return self.get_display_name(Locale('en'))
+
+    # { General Locale Display Names
+
+    @property
+    def languages(self) -> localedata.LocaleDataDict:
+        """Mapping of language codes to translated language names.
+
+        >>> Locale('de', 'DE').languages['ja']
+        u'Japanisch'
+
+        See `ISO 639 <https://www.loc.gov/standards/iso639-2/>`_ for
+        more information.
+        """
+        return self._data['languages']
+
+    @property
+    def scripts(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('en', 'US').scripts['Hira']
+        u'Hiragana'
+
+        See `ISO 15924 <https://www.unicode.org/iso15924/>`_
+        for more information.
+        """
+        return self._data['scripts']
+
+    @property
+    def territories(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('es', 'CO').territories['DE']
+        u'Alemania'
+
+        See `ISO 3166 <https://en.wikipedia.org/wiki/ISO_3166>`_
+        for more information.
+        """
+        return self._data['territories']
+
+    @property
+    def variants(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('de', 'DE').variants['1901']
+        u'Alte deutsche Rechtschreibung'
+        """
+        return self._data['variants']
+
+    # { Number Formatting
+
+    @property
+    def currencies(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to translated currency names.  This
+        only returns the generic form of the currency name, not the count
+        specific one.  If an actual number is requested use the
+        :func:`babel.numbers.get_currency_name` function.
+
+        >>> Locale('en').currencies['COP']
+        u'Colombian Peso'
+        >>> Locale('de', 'DE').currencies['COP']
+        u'Kolumbianischer Peso'
+        """
+        return self._data['currency_names']
+
+    @property
+    def currency_symbols(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to symbols.
+
+        >>> Locale('en', 'US').currency_symbols['USD']
+        u'$'
+        >>> Locale('es', 'CO').currency_symbols['USD']
+        u'US$'
+        """
+        return self._data['currency_symbols']
+
+    @property
+    def number_symbols(self) -> localedata.LocaleDataDict:
+        """Symbols used in number formatting by number system.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('fr', 'FR').number_symbols["latn"]['decimal']
+        u','
+        >>> Locale('fa', 'IR').number_symbols["arabext"]['decimal']
+        u'٫'
+        >>> Locale('fa', 'IR').number_symbols["latn"]['decimal']
+        u'.'
+        """
+        return self._data['number_symbols']
+
+    @property
+    def other_numbering_systems(self) -> localedata.LocaleDataDict:
+        """
+        Mapping of other numbering systems available for the locale.
+        See: https://www.unicode.org/reports/tr35/tr35-numbers.html#otherNumberingSystems
+
+        >>> Locale('el', 'GR').other_numbering_systems['traditional']
+        u'grek'
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+        """
+        return self._data['numbering_systems']
+
+    @property
+    def default_numbering_system(self) -> str:
+        """The default numbering system used by the locale.
+        >>> Locale('el', 'GR').default_numbering_system
+        u'latn'
+        """
+        return self._data['default_numbering_system']
+
+    @property
+    def decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').decimal_formats[None]
+        <NumberPattern u'#,##0.###'>
+        """
+        return self._data['decimal_formats']
+
+    @property
+    def compact_decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_decimal_formats["short"]["one"]["1000"]
+        <NumberPattern u'0K'>
+        """
+        return self._data['compact_decimal_formats']
+
+    @property
+    def currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').currency_formats['standard']
+        <NumberPattern u'\\xa4#,##0.00'>
+        >>> Locale('en', 'US').currency_formats['accounting']
+        <NumberPattern u'\\xa4#,##0.00;(\\xa4#,##0.00)'>
+        """
+        return self._data['currency_formats']
+
+    @property
+    def compact_currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_currency_formats["short"]["one"]["1000"]
+        <NumberPattern u'¤0K'>
+        """
+        return self._data['compact_currency_formats']
+
+    @property
+    def percent_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for percent number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').percent_formats[None]
+        <NumberPattern u'#,##0%'>
+        """
+        return self._data['percent_formats']
+
+    @property
+    def scientific_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for scientific number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').scientific_formats[None]
+        <NumberPattern u'#E0'>
+        """
+        return self._data['scientific_formats']
+
+    # { Calendar Information and Date Formatting
+
+    @property
+    def periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for day periods (AM/PM).
+
+        >>> Locale('en', 'US').periods['am']
+        u'AM'
+        """
+        try:
+            return self._data['day_periods']['stand-alone']['wide']
+        except KeyError:
+            return localedata.LocaleDataDict({})  # pragma: no cover
+
+    @property
+    def day_periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for various day periods (not necessarily only AM/PM).
+
+        These are not meant to be used without the relevant `day_period_rules`.
+        """
+        return self._data['day_periods']
+
+    @property
+    def day_period_rules(self) -> localedata.LocaleDataDict:
+        """Day period rules for the locale.  Used by `get_period_id`.
+        """
+        return self._data.get('day_period_rules', localedata.LocaleDataDict({}))
+
+    @property
+    def days(self) -> localedata.LocaleDataDict:
+        """Locale display names for weekdays.
+
+        >>> Locale('de', 'DE').days['format']['wide'][3]
+        u'Donnerstag'
+        """
+        return self._data['days']
+
+    @property
+    def months(self) -> localedata.LocaleDataDict:
+        """Locale display names for months.
+
+        >>> Locale('de', 'DE').months['format']['wide'][10]
+        u'Oktober'
+        """
+        return self._data['months']
+
+    @property
+    def quarters(self) -> localedata.LocaleDataDict:
+        """Locale display names for quarters.
+
+        >>> Locale('de', 'DE').quarters['format']['wide'][1]
+        u'1. Quartal'
+        """
+        return self._data['quarters']
+
+    @property
+    def eras(self) -> localedata.LocaleDataDict:
+        """Locale display names for eras.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').eras['wide'][1]
+        u'Anno Domini'
+        >>> Locale('en', 'US').eras['abbreviated'][0]
+        u'BC'
+        """
+        return self._data['eras']
+
+    @property
+    def time_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_zones['Europe/London']['long']['daylight']
+        u'British Summer Time'
+        >>> Locale('en', 'US').time_zones['America/St_Johns']['city']
+        u'St. John\u2019s'
+        """
+        return self._data['time_zones']
+
+    @property
+    def meta_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for meta time zones.
+
+        Meta time zones are basically groups of different Olson time zones that
+        have the same GMT offset and daylight savings time.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').meta_zones['Europe_Central']['long']['daylight']
+        u'Central European Summer Time'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['meta_zones']
+
+    @property
+    def zone_formats(self) -> localedata.LocaleDataDict:
+        """Patterns related to the formatting of time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').zone_formats['fallback']
+        u'%(1)s (%(0)s)'
+        >>> Locale('pt', 'BR').zone_formats['region']
+        u'Hor\\xe1rio %s'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['zone_formats']
+
+    @property
+    def first_week_day(self) -> int:
+        """The first day of a week, with 0 being Monday.
+
+        >>> Locale('de', 'DE').first_week_day
+        0
+        >>> Locale('en', 'US').first_week_day
+        6
+        """
+        return self._data['week_data']['first_day']
+
+    @property
+    def weekend_start(self) -> int:
+        """The day the weekend starts, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_start
+        5
+        """
+        return self._data['week_data']['weekend_start']
+
+    @property
+    def weekend_end(self) -> int:
+        """The day the weekend ends, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_end
+        6
+        """
+        return self._data['week_data']['weekend_end']
+
+    @property
+    def min_week_days(self) -> int:
+        """The minimum number of days in a week so that the week is counted as
+        the first week of a year or month.
+
+        >>> Locale('de', 'DE').min_week_days
+        4
+        """
+        return self._data['week_data']['min_days']
+
+    @property
+    def date_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for date formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').date_formats['short']
+        <DateTimePattern u'M/d/yy'>
+        >>> Locale('fr', 'FR').date_formats['long']
+        <DateTimePattern u'd MMMM y'>
+        """
+        return self._data['date_formats']
+
+    @property
+    def time_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for time formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_formats['short']
+        <DateTimePattern u'h:mm\u202fa'>
+        >>> Locale('fr', 'FR').time_formats['long']
+        <DateTimePattern u'HH:mm:ss z'>
+        """
+        return self._data['time_formats']
+
+    @property
+    def datetime_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for datetime formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').datetime_formats['full']
+        u'{1}, {0}'
+        >>> Locale('th').datetime_formats['medium']
+        u'{1} {0}'
+        """
+        return self._data['datetime_formats']
+
+    @property
+    def datetime_skeletons(self) -> localedata.LocaleDataDict:
+        """Locale patterns for formatting parts of a datetime.
+
+        >>> Locale('en').datetime_skeletons['MEd']
+        <DateTimePattern u'E, M/d'>
+        >>> Locale('fr').datetime_skeletons['MEd']
+        <DateTimePattern u'E dd/MM'>
+        >>> Locale('fr').datetime_skeletons['H']
+        <DateTimePattern u"HH 'h'">
+        """
+        return self._data['datetime_skeletons']
+
+    @property
+    def interval_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for interval formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        How to format date intervals in Finnish when the day is the
+        smallest changing component:
+
+        >>> Locale('fi_FI').interval_formats['MEd']['d']
+        [u'E d.\u2009\u2013\u2009', u'E d.M.']
+
+        .. seealso::
+
+           The primary API to use this data is :py:func:`babel.dates.format_interval`.
+
+
+        :rtype: dict[str, dict[str, list[str]]]
+        """
+        return self._data['interval_formats']
+
+    @property
+    def plural_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').plural_form(1)
+        'one'
+        >>> Locale('en').plural_form(0)
+        'other'
+        >>> Locale('fr').plural_form(0)
+        'one'
+        >>> Locale('ru').plural_form(100)
+        'many'
+        """
+        return self._data.get('plural_form', _default_plural_rule)
+
+    @property
+    def list_patterns(self) -> localedata.LocaleDataDict:
+        """Patterns for generating lists
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').list_patterns['standard']['start']
+        u'{0}, {1}'
+        >>> Locale('en').list_patterns['standard']['end']
+        u'{0}, and {1}'
+        >>> Locale('en_GB').list_patterns['standard']['end']
+        u'{0} and {1}'
+        """
+        return self._data['list_patterns']
+
+    @property
+    def ordinal_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').ordinal_form(1)
+        'one'
+        >>> Locale('en').ordinal_form(2)
+        'two'
+        >>> Locale('en').ordinal_form(3)
+        'few'
+        >>> Locale('fr').ordinal_form(2)
+        'other'
+        >>> Locale('ru').ordinal_form(100)
+        'other'
+        """
+        return self._data.get('ordinal_form', _default_plural_rule)
+
+    @property
+    def measurement_systems(self) -> localedata.LocaleDataDict:
+        """Localized names for various measurement systems.
+
+        >>> Locale('fr', 'FR').measurement_systems['US']
+        u'am\\xe9ricain'
+        >>> Locale('en', 'US').measurement_systems['US']
+        u'US'
+
+        """
+        return self._data['measurement_systems']
+
+    @property
+    def character_order(self) -> str:
+        """The text direction for the language.
+
+        >>> Locale('de', 'DE').character_order
+        'left-to-right'
+        >>> Locale('ar', 'SA').character_order
+        'right-to-left'
+        """
+        return self._data['character_order']
+
+    @property
+    def text_direction(self) -> str:
+        """The text direction for the language in CSS short-hand form.
+
+        >>> Locale('de', 'DE').text_direction
+        'ltr'
+        >>> Locale('ar', 'SA').text_direction
+        'rtl'
+        """
+        return ''.join(word[0] for word in self.character_order.split('-'))
+
+    @property
+    def unit_display_names(self) -> localedata.LocaleDataDict:
+        """Display names for units of measurement.
+
+        .. seealso::
+
+           You may want to use :py:func:`babel.units.get_unit_name` instead.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        """
+        return self._data['unit_display_names']
+
+
+def default_locale(
+    category: str | tuple[str, ...] | list[str] | None = None,
+    aliases: Mapping[str, str] = LOCALE_ALIASES,
+) -> str | None:
+    """Returns the system default locale for a given category, based on
+    environment variables.
+
+    >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE']:
+    ...     os.environ[name] = ''
+    >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+    >>> default_locale('LC_MESSAGES')
+    'fr_FR'
+
+    The "C" or "POSIX" pseudo-locales are treated as aliases for the
+    "en_US_POSIX" locale:
+
+    >>> os.environ['LC_MESSAGES'] = 'POSIX'
+    >>> default_locale('LC_MESSAGES')
+    'en_US_POSIX'
+
+    The following fallbacks to the variable are always considered:
+
+    - ``LANGUAGE``
+    - ``LC_ALL``
+    - ``LC_CTYPE``
+    - ``LANG``
+
+    :param category: one or more of the ``LC_XXX`` environment variable names
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+
+    varnames = ('LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LANG')
+    if category:
+        if isinstance(category, str):
+            varnames = (category, *varnames)
+        elif isinstance(category, (list, tuple)):
+            varnames = (*category, *varnames)
+        else:
+            raise TypeError(f"Invalid type for category: {category!r}")
+
+    for name in varnames:
+        if not name:
+            continue
+        locale = os.getenv(name)
+        if locale:
+            if name == 'LANGUAGE' and ':' in locale:
+                # the LANGUAGE variable may contain a colon-separated list of
+                # language codes; we just pick the language on the list
+                locale = locale.split(':')[0]
+            if locale.split('.')[0] in ('C', 'POSIX'):
+                locale = 'en_US_POSIX'
+            elif aliases and locale in aliases:
+                locale = aliases[locale]
+            try:
+                return get_locale_identifier(parse_locale(locale))
+            except ValueError:
+                pass
+    return None
+
+
+def negotiate_locale(preferred: Iterable[str], available: Iterable[str], sep: str = '_', aliases: Mapping[str, str] = LOCALE_ALIASES) -> str | None:
+    """Find the best match between available and requested locale strings.
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+    'de_DE'
+    >>> negotiate_locale(['de_DE', 'en_US'], ['en', 'de'])
+    'de'
+
+    Case is ignored by the algorithm, the result uses the case of the preferred
+    locale identifier:
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    By default, some web browsers unfortunately do not include the territory
+    in the locale identifier for many locales, and some don't even allow the
+    user to easily add the territory. So while you may prefer using qualified
+    locale identifiers in your web-application, they would not normally match
+    the language-only locale sent by such browsers. To workaround that, this
+    function uses a default mapping of commonly used language-only locale
+    identifiers to identifiers including the territory:
+
+    >>> negotiate_locale(['ja', 'en_US'], ['ja_JP', 'en_US'])
+    'ja_JP'
+
+    Some browsers even use an incorrect or outdated language code, such as "no"
+    for Norwegian, where the correct locale identifier would actually be "nb_NO"
+    (Bokmål) or "nn_NO" (Nynorsk). The aliases are intended to take care of
+    such cases, too:
+
+    >>> negotiate_locale(['no', 'sv'], ['nb_NO', 'sv_SE'])
+    'nb_NO'
+
+    You can override this default mapping by passing a different `aliases`
+    dictionary to this function, or you can bypass the behavior althogher by
+    setting the `aliases` parameter to `None`.
+
+    :param preferred: the list of locale strings preferred by the user
+    :param available: the list of locale strings available
+    :param sep: character that separates the different parts of the locale
+                strings
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+    available = [a.lower() for a in available if a]
+    for locale in preferred:
+        ll = locale.lower()
+        if ll in available:
+            return locale
+        if aliases:
+            alias = aliases.get(ll)
+            if alias:
+                alias = alias.replace('_', sep)
+                if alias.lower() in available:
+                    return alias
+        parts = locale.split(sep)
+        if len(parts) > 1 and parts[0].lower() in available:
+            return parts[0]
+    return None
+
+
+def parse_locale(
+    identifier: str,
+    sep: str = '_',
+) -> tuple[str, str | None, str | None, str | None] | tuple[str, str | None, str | None, str | None, str | None]:
+    """Parse a locale identifier into a tuple of the form ``(language,
+    territory, script, variant, modifier)``.
+
+    >>> parse_locale('zh_CN')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh_Hans_CN')
+    ('zh', 'CN', 'Hans', None)
+    >>> parse_locale('ca_es_valencia')
+    ('ca', 'ES', None, 'VALENCIA')
+    >>> parse_locale('en_150')
+    ('en', '150', None, None)
+    >>> parse_locale('en_us_posix')
+    ('en', 'US', None, 'POSIX')
+    >>> parse_locale('it_IT@euro')
+    ('it', 'IT', None, None, 'euro')
+    >>> parse_locale('it_IT@custom')
+    ('it', 'IT', None, None, 'custom')
+    >>> parse_locale('it_IT@')
+    ('it', 'IT', None, None)
+
+    The default component separator is "_", but a different separator can be
+    specified using the `sep` parameter.
+
+    The optional modifier is always separated with "@" and at the end:
+
+    >>> parse_locale('zh-CN', sep='-')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh-CN@custom', sep='-')
+    ('zh', 'CN', None, None, 'custom')
+
+    If the identifier cannot be parsed into a locale, a `ValueError` exception
+    is raised:
+
+    >>> parse_locale('not_a_LOCALE_String')
+    Traceback (most recent call last):
+      ...
+    ValueError: 'not_a_LOCALE_String' is not a valid locale identifier
+
+    Encoding information is removed from the identifier, while modifiers are
+    kept:
+
+    >>> parse_locale('en_US.UTF-8')
+    ('en', 'US', None, None)
+    >>> parse_locale('de_DE.iso885915@euro')
+    ('de', 'DE', None, None, 'euro')
+
+    See :rfc:`4646` for more information.
+
+    :param identifier: the locale identifier string
+    :param sep: character that separates the different components of the locale
+                identifier
+    :raise `ValueError`: if the string does not appear to be a valid locale
+                         identifier
+    """
+    if not identifier:
+        raise ValueError("empty locale identifier")
+    identifier, _, modifier = identifier.partition('@')
+    if '.' in identifier:
+        # this is probably the charset/encoding, which we don't care about
+        identifier = identifier.split('.', 1)[0]
+
+    parts = identifier.split(sep)
+    lang = parts.pop(0).lower()
+    if not lang.isalpha():
+        raise ValueError(f"expected only letters, got {lang!r}")
+
+    script = territory = variant = None
+    if parts and len(parts[0]) == 4 and parts[0].isalpha():
+        script = parts.pop(0).title()
+
+    if parts:
+        if len(parts[0]) == 2 and parts[0].isalpha():
+            territory = parts.pop(0).upper()
+        elif len(parts[0]) == 3 and parts[0].isdigit():
+            territory = parts.pop(0)
+
+    if parts and (
+        len(parts[0]) == 4 and parts[0][0].isdigit() or
+        len(parts[0]) >= 5 and parts[0][0].isalpha()
+    ):
+        variant = parts.pop().upper()
+
+    if parts:
+        raise ValueError(f"{identifier!r} is not a valid locale identifier")
+
+    # TODO(3.0): always return a 5-tuple
+    if modifier:
+        return lang, territory, script, variant, modifier
+    else:
+        return lang, territory, script, variant
+
+
+def get_locale_identifier(
+    tup: tuple[str]
+    | tuple[str, str | None]
+    | tuple[str, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None, str | None],
+    sep: str = "_",
+) -> str:
+    """The reverse of :func:`parse_locale`.  It creates a locale identifier out
+    of a ``(language, territory, script, variant, modifier)`` tuple.  Items can be set to
+    ``None`` and trailing ``None``\\s can also be left out of the tuple.
+
+    >>> get_locale_identifier(('de', 'DE', None, '1999', 'custom'))
+    'de_DE_1999@custom'
+    >>> get_locale_identifier(('fi', None, None, None, 'custom'))
+    'fi@custom'
+
+
+    .. versionadded:: 1.0
+
+    :param tup: the tuple as returned by :func:`parse_locale`.
+    :param sep: the separator for the identifier.
+    """
+    tup = tuple(tup[:5])  # type: ignore  # length should be no more than 5
+    lang, territory, script, variant, modifier = tup + (None,) * (5 - len(tup))
+    ret = sep.join(filter(None, (lang, script, territory, variant)))
+    return f'{ret}@{modifier}' if modifier else ret

rtme/lib/python3.10/site-packages/babel/dates.py

@@ -0,0 +1,1999 @@
+"""
+    babel.dates
+    ~~~~~~~~~~~
+
+    Locale dependent formatting and parsing of dates and times.
+
+    The default locale for the functions in this module is determined by the
+    following environment variables, in that order:
+
+     * ``LC_TIME``,
+     * ``LC_ALL``, and
+     * ``LANG``
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import warnings
+from functools import lru_cache
+from typing import TYPE_CHECKING, Literal, SupportsInt
+
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+    import zoneinfo
+
+import datetime
+from collections.abc import Iterable
+
+from babel import localtime
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+    _Instant: TypeAlias = datetime.date | datetime.time | float | None
+    _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
+    _Context: TypeAlias = Literal['format', 'stand-alone']
+    _DtOrTzinfo: TypeAlias = datetime.datetime | datetime.tzinfo | str | int | datetime.time | None
+
+# "If a given short metazone form is known NOT to be understood in a given
+#  locale and the parent locale has this value such that it would normally
+#  be inherited, the inheritance of this value can be explicitly disabled by
+#  use of the 'no inheritance marker' as the value, which is 3 simultaneous [sic]
+#  empty set characters ( U+2205 )."
+#  - https://www.unicode.org/reports/tr35/tr35-dates.html#Metazone_Names
+
+NO_INHERITANCE_MARKER = '\u2205\u2205\u2205'
+
+UTC = datetime.timezone.utc
+LOCALTZ = localtime.LOCALTZ
+
+LC_TIME = default_locale('LC_TIME')
+
+
+def _localize(tz: datetime.tzinfo, dt: datetime.datetime) -> datetime.datetime:
+    # Support localizing with both pytz and zoneinfo tzinfos
+    # nothing to do
+    if dt.tzinfo is tz:
+        return dt
+
+    if hasattr(tz, 'localize'):  # pytz
+        return tz.localize(dt)
+
+    if dt.tzinfo is None:
+        # convert naive to localized
+        return dt.replace(tzinfo=tz)
+
+    # convert timezones
+    return dt.astimezone(tz)
+
+
+def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime.datetime | None, datetime.tzinfo]:
+    """
+    Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.
+
+    See the docs for this function's callers for semantics.
+
+    :rtype: tuple[datetime, tzinfo]
+    """
+    if dt_or_tzinfo is None:
+        dt = datetime.datetime.now()
+        tzinfo = LOCALTZ
+    elif isinstance(dt_or_tzinfo, str):
+        dt = None
+        tzinfo = get_timezone(dt_or_tzinfo)
+    elif isinstance(dt_or_tzinfo, int):
+        dt = None
+        tzinfo = UTC
+    elif isinstance(dt_or_tzinfo, (datetime.datetime, datetime.time)):
+        dt = _get_datetime(dt_or_tzinfo)
+        tzinfo = dt.tzinfo if dt.tzinfo is not None else UTC
+    else:
+        dt = None
+        tzinfo = dt_or_tzinfo
+    return dt, tzinfo
+
+
+def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) -> str:
+    """
+    Get the timezone name out of a time, datetime, or tzinfo object.
+
+    :rtype: str
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    if hasattr(tzinfo, 'zone'):  # pytz object
+        return tzinfo.zone
+    elif hasattr(tzinfo, 'key') and tzinfo.key is not None:  # ZoneInfo object
+        return tzinfo.key
+    else:
+        return tzinfo.tzname(dt or datetime.datetime.now(UTC))
+
+
+def _get_datetime(instant: _Instant) -> datetime.datetime:
+    """
+    Get a datetime out of an "instant" (date, time, datetime, number).
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    If the instant is None, the current moment is used.
+    If the instant is a time, it's augmented with today's date.
+
+    Dates are converted to naive datetimes with midnight as the time component.
+
+    >>> from datetime import date, datetime
+    >>> _get_datetime(date(2015, 1, 1))
+    datetime.datetime(2015, 1, 1, 0, 0)
+
+    UNIX timestamps are converted to datetimes.
+
+    >>> _get_datetime(1400000000)
+    datetime.datetime(2014, 5, 13, 16, 53, 20)
+
+    Other values are passed through as-is.
+
+    >>> x = datetime(2015, 1, 1)
+    >>> _get_datetime(x) is x
+    True
+
+    :param instant: date, time, datetime, integer, float or None
+    :type instant: date|time|datetime|int|float|None
+    :return: a datetime
+    :rtype: datetime
+    """
+    if instant is None:
+        return datetime.datetime.now(UTC).replace(tzinfo=None)
+    elif isinstance(instant, (int, float)):
+        return datetime.datetime.fromtimestamp(instant, UTC).replace(tzinfo=None)
+    elif isinstance(instant, datetime.time):
+        return datetime.datetime.combine(datetime.date.today(), instant)
+    elif isinstance(instant, datetime.date) and not isinstance(instant, datetime.datetime):
+        return datetime.datetime.combine(instant, datetime.time())
+    # TODO (3.x): Add an assertion/type check for this fallthrough branch:
+    return instant
+
+
+def _ensure_datetime_tzinfo(dt: datetime.datetime, tzinfo: datetime.tzinfo | None = None) -> datetime.datetime:
+    """
+    Ensure the datetime passed has an attached tzinfo.
+
+    If the datetime is tz-naive to begin with, UTC is attached.
+
+    If a tzinfo is passed in, the datetime is normalized to that timezone.
+
+    >>> from datetime import datetime
+    >>> _get_tz_name(_ensure_datetime_tzinfo(datetime(2015, 1, 1)))
+    'UTC'
+
+    >>> tz = get_timezone("Europe/Stockholm")
+    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1, 13, 15, tzinfo=UTC), tzinfo=tz).hour
+    14
+
+    :param datetime: Datetime to augment.
+    :param tzinfo: optional tzinfo
+    :return: datetime with tzinfo
+    :rtype: datetime
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    if tzinfo is not None:
+        dt = dt.astimezone(get_timezone(tzinfo))
+        if hasattr(tzinfo, 'normalize'):  # pytz
+            dt = tzinfo.normalize(dt)
+    return dt
+
+
+def _get_time(
+    time: datetime.time | datetime.datetime | None,
+    tzinfo: datetime.tzinfo | None = None,
+) -> datetime.time:
+    """
+    Get a timezoned time from a given instant.
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    :param time: time, datetime or None
+    :rtype: time
+    """
+    if time is None:
+        time = datetime.datetime.now(UTC)
+    elif isinstance(time, (int, float)):
+        time = datetime.datetime.fromtimestamp(time, UTC)
+
+    if time.tzinfo is None:
+        time = time.replace(tzinfo=UTC)
+
+    if isinstance(time, datetime.datetime):
+        if tzinfo is not None:
+            time = time.astimezone(tzinfo)
+            if hasattr(tzinfo, 'normalize'):  # pytz
+                time = tzinfo.normalize(time)
+        time = time.timetz()
+    elif tzinfo is not None:
+        time = time.replace(tzinfo=tzinfo)
+    return time
+
+
+def get_timezone(zone: str | datetime.tzinfo | None = None) -> datetime.tzinfo:
+    """Looks up a timezone by name and returns it.  The timezone object
+    returned comes from ``pytz`` or ``zoneinfo``, whichever is available.
+    It corresponds to the `tzinfo` interface and can be used with all of
+    the functions of Babel that operate with dates.
+
+    If a timezone is not known a :exc:`LookupError` is raised.  If `zone`
+    is ``None`` a local zone object is returned.
+
+    :param zone: the name of the timezone to look up.  If a timezone object
+                 itself is passed in, it's returned unchanged.
+    """
+    if zone is None:
+        return LOCALTZ
+    if not isinstance(zone, str):
+        return zone
+
+    if pytz:
+        try:
+            return pytz.timezone(zone)
+        except pytz.UnknownTimeZoneError as e:
+            exc = e
+    else:
+        assert zoneinfo
+        try:
+            return zoneinfo.ZoneInfo(zone)
+        except zoneinfo.ZoneInfoNotFoundError as e:
+            exc = e
+
+    raise LookupError(f"Unknown timezone {zone}") from exc
+
+
+def get_period_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'stand-alone',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the names for day periods (AM/PM) used by the locale.
+
+    >>> get_period_names(locale='en_US')['am']
+    u'AM'
+
+    :param width: the width to use, one of "abbreviated", "narrow", or "wide"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).day_periods[context][width]
+
+
+def get_day_names(
+    width: Literal['abbreviated', 'narrow', 'short', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the day names used by the locale for the specified format.
+
+    >>> get_day_names('wide', locale='en_US')[1]
+    u'Tuesday'
+    >>> get_day_names('short', locale='en_US')[1]
+    u'Tu'
+    >>> get_day_names('abbreviated', locale='es')[1]
+    u'mar'
+    >>> get_day_names('narrow', context='stand-alone', locale='de_DE')[1]
+    u'D'
+
+    :param width: the width to use, one of "wide", "abbreviated", "short" or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).days[context][width]
+
+
+def get_month_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the month names used by the locale for the specified format.
+
+    >>> get_month_names('wide', locale='en_US')[1]
+    u'January'
+    >>> get_month_names('abbreviated', locale='es')[1]
+    u'ene'
+    >>> get_month_names('narrow', context='stand-alone', locale='de_DE')[1]
+    u'J'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).months[context][width]
+
+
+def get_quarter_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the quarter names used by the locale for the specified format.
+
+    >>> get_quarter_names('wide', locale='en_US')[1]
+    u'1st quarter'
+    >>> get_quarter_names('abbreviated', locale='de_DE')[1]
+    u'Q1'
+    >>> get_quarter_names('narrow', locale='de_DE')[1]
+    u'1'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).quarters[context][width]
+
+
+def get_era_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the era names used by the locale for the specified format.
+
+    >>> get_era_names('wide', locale='en_US')[1]
+    u'Anno Domini'
+    >>> get_era_names('abbreviated', locale='de_DE')[1]
+    u'n. Chr.'
+
+    :param width: the width to use, either "wide", "abbreviated", or "narrow"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).eras[width]
+
+
+def get_date_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the date formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_date_format(locale='en_US')
+    <DateTimePattern u'MMM d, y'>
+    >>> get_date_format('full', locale='de_DE')
+    <DateTimePattern u'EEEE, d. MMMM y'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).date_formats[format]
+
+
+def get_datetime_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the datetime formatting patterns used by the locale for the
+    specified format.
+
+    >>> get_datetime_format(locale='en_US')
+    u'{1}, {0}'
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    patterns = Locale.parse(locale or LC_TIME).datetime_formats
+    if format not in patterns:
+        format = None
+    return patterns[format]
+
+
+def get_time_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the time formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_time_format(locale='en_US')
+    <DateTimePattern u'h:mm:ss\u202fa'>
+    >>> get_time_format('full', locale='de_DE')
+    <DateTimePattern u'HH:mm:ss zzzz'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).time_formats[format]
+
+
+def get_timezone_gmt(
+    datetime: _Instant = None,
+    width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
+    locale: Locale | str | None = None,
+    return_z: bool = False,
+) -> str:
+    """Return the timezone associated with the given `datetime` object formatted
+    as string indicating the offset from GMT.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> get_timezone_gmt(dt, locale='en')
+    u'GMT+00:00'
+    >>> get_timezone_gmt(dt, locale='en', return_z=True)
+    'Z'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    u'+00'
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
+    >>> get_timezone_gmt(dt, locale='en')
+    u'GMT-07:00'
+    >>> get_timezone_gmt(dt, 'short', locale='en')
+    u'-0700'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    u'-07'
+
+    The long format depends on the locale, for example in France the acronym
+    UTC string is used instead of GMT:
+
+    >>> get_timezone_gmt(dt, 'long', locale='fr_FR')
+    u'UTC-07:00'
+
+    .. versionadded:: 0.9
+
+    :param datetime: the ``datetime`` object; if `None`, the current date and
+                     time in UTC is used
+    :param width: either "long" or "short" or "iso8601" or "iso8601_short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_z: True or False; Function returns indicator "Z"
+                     when local time offset is 0
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime))
+    locale = Locale.parse(locale or LC_TIME)
+
+    offset = datetime.tzinfo.utcoffset(datetime)
+    seconds = offset.days * 24 * 60 * 60 + offset.seconds
+    hours, seconds = divmod(seconds, 3600)
+    if return_z and hours == 0 and seconds == 0:
+        return 'Z'
+    elif seconds == 0 and width == 'iso8601_short':
+        return '%+03d' % hours
+    elif width == 'short' or width == 'iso8601_short':
+        pattern = '%+03d%02d'
+    elif width == 'iso8601':
+        pattern = '%+03d:%02d'
+    else:
+        pattern = locale.zone_formats['gmt'] % '%+03d:%02d'
+    return pattern % (hours, seconds // 60)
+
+
+def get_timezone_location(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    locale: Locale | str | None = None,
+    return_city: bool = False,
+) -> str:
+    """Return a representation of the given timezone using "location format".
+
+    The result depends on both the local display name of the country and the
+    city associated with the time zone:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> print(get_timezone_location(tz, locale='de_DE'))
+    Kanada (St. John’s) (Ortszeit)
+    >>> print(get_timezone_location(tz, locale='en'))
+    Canada (St. John’s) Time
+    >>> print(get_timezone_location(tz, locale='en', return_city=True))
+    St. John’s
+    >>> tz = get_timezone('America/Mexico_City')
+    >>> get_timezone_location(tz, locale='de_DE')
+    u'Mexiko (Mexiko-Stadt) (Ortszeit)'
+
+    If the timezone is associated with a country that uses only a single
+    timezone, just the localized country name is returned:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Mitteleurop\\xe4ische Zeit'
+
+    .. versionadded:: 0.9
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if `None`, the current date and time in
+                         UTC is assumed
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_city: True or False, if True then return exemplar city (location)
+                        for the time zone
+    :return: the localized timezone name using location format
+
+    """
+    locale = Locale.parse(locale or LC_TIME)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+
+    info = locale.time_zones.get(zone, {})
+
+    # Otherwise, if there is only one timezone for the country, return the
+    # localized country name
+    region_format = locale.zone_formats['region']
+    territory = get_global('zone_territories').get(zone)
+    if territory not in locale.territories:
+        territory = 'ZZ'  # invalid/unknown
+    territory_name = locale.territories[territory]
+    if not return_city and territory and len(get_global('territory_zones').get(territory, [])) == 1:
+        return region_format % territory_name
+
+    # Otherwise, include the city in the output
+    fallback_format = locale.zone_formats['fallback']
+    if 'city' in info:
+        city_name = info['city']
+    else:
+        metazone = get_global('meta_zones').get(zone)
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if 'city' in metazone_info:
+            city_name = metazone_info['city']
+        elif '/' in zone:
+            city_name = zone.split('/', 1)[1].replace('_', ' ')
+        else:
+            city_name = zone.replace('_', ' ')
+
+    if return_city:
+        return city_name
+    return region_format % (fallback_format % {
+        '0': city_name,
+        '1': territory_name,
+    })
+
+
+def get_timezone_name(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    width: Literal['long', 'short'] = 'long',
+    uncommon: bool = False,
+    locale: Locale | str | None = None,
+    zone_variant: Literal['generic', 'daylight', 'standard'] | None = None,
+    return_zone: bool = False,
+) -> str:
+    r"""Return the localized display name for the given timezone. The timezone
+    may be specified using a ``datetime`` or `tzinfo` object.
+
+    >>> from datetime import time
+    >>> dt = time(15, 30, tzinfo=get_timezone('America/Los_Angeles'))
+    >>> get_timezone_name(dt, locale='en_US')  # doctest: +SKIP
+    u'Pacific Standard Time'
+    >>> get_timezone_name(dt, locale='en_US', return_zone=True)
+    'America/Los_Angeles'
+    >>> get_timezone_name(dt, width='short', locale='en_US')  # doctest: +SKIP
+    u'PST'
+
+    If this function gets passed only a `tzinfo` object and no concrete
+    `datetime`,  the returned display name is independent of daylight savings
+    time. This can be used for example for selecting timezones, or to set the
+    time of events that recur across DST changes:
+
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> get_timezone_name(tz, locale='en_US')
+    u'Pacific Time'
+    >>> get_timezone_name(tz, 'short', locale='en_US')
+    u'PT'
+
+    If no localized display name for the timezone is available, and the timezone
+    is associated with a country that uses only a single timezone, the name of
+    that country is returned, formatted according to the locale:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Mitteleurop\xe4ische Zeit'
+    >>> get_timezone_name(tz, locale='pt_BR')
+    u'Hor\xe1rio da Europa Central'
+
+    On the other hand, if the country uses multiple timezones, the city is also
+    included in the representation:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Neufundland-Zeit'
+
+    Note that short format is currently not supported for all timezones and
+    all locales.  This is partially because not every timezone has a short
+    code in every locale.  In that case it currently falls back to the long
+    format.
+
+    For more information see `LDML Appendix J: Time Zone Display Names
+    <https://www.unicode.org/reports/tr35/#Time_Zone_Fallback>`_
+
+    .. versionadded:: 0.9
+
+    .. versionchanged:: 1.0
+       Added `zone_variant` support.
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if a ``tzinfo`` object is used, the
+                         resulting display name will be generic, i.e.
+                         independent of daylight savings time; if `None`, the
+                         current date in UTC is assumed
+    :param width: either "long" or "short"
+    :param uncommon: deprecated and ignored
+    :param zone_variant: defines the zone variation to return.  By default the
+                           variation is defined from the datetime object
+                           passed in.  If no datetime object is passed in, the
+                           ``'generic'`` variation is assumed.  The following
+                           values are valid: ``'generic'``, ``'daylight'`` and
+                           ``'standard'``.
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_zone: True or False. If true then function
+                        returns long time zone ID
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    locale = Locale.parse(locale or LC_TIME)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    if zone_variant is None:
+        if dt is None:
+            zone_variant = 'generic'
+        else:
+            dst = tzinfo.dst(dt)
+            zone_variant = "daylight" if dst else "standard"
+    else:
+        if zone_variant not in ('generic', 'standard', 'daylight'):
+            raise ValueError('Invalid zone variation')
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+    if return_zone:
+        return zone
+    info = locale.time_zones.get(zone, {})
+    # Try explicitly translated zone names first
+    if width in info and zone_variant in info[width]:
+        return info[width][zone_variant]
+
+    metazone = get_global('meta_zones').get(zone)
+    if metazone:
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if width in metazone_info:
+            name = metazone_info[width].get(zone_variant)
+            if width == 'short' and name == NO_INHERITANCE_MARKER:
+                # If the short form is marked no-inheritance,
+                # try to fall back to the long name instead.
+                name = metazone_info.get('long', {}).get(zone_variant)
+            if name:
+                return name
+
+    # If we have a concrete datetime, we assume that the result can't be
+    # independent of daylight savings time, so we return the GMT offset
+    if dt is not None:
+        return get_timezone_gmt(dt, width=width, locale=locale)
+
+    return get_timezone_location(dt_or_tzinfo, locale=locale)
+
+
+def format_date(
+    date: datetime.date | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    locale: Locale | str | None = None,
+) -> str:
+    """Return a date formatted according to the given pattern.
+
+    >>> from datetime import date
+    >>> d = date(2007, 4, 1)
+    >>> format_date(d, locale='en_US')
+    u'Apr 1, 2007'
+    >>> format_date(d, format='full', locale='de_DE')
+    u'Sonntag, 1. April 2007'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom date pattern:
+
+    >>> format_date(d, "EEE, MMM d, ''yy", locale='en')
+    u"Sun, Apr 1, '07"
+
+    :param date: the ``date`` or ``datetime`` object; if `None`, the current
+                 date is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    if date is None:
+        date = datetime.date.today()
+    elif isinstance(date, datetime.datetime):
+        date = date.date()
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_date_format(format, locale=locale)
+    pattern = parse_pattern(format)
+    return pattern.apply(date, locale)
+
+
+def format_datetime(
+    datetime: _Instant = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a date formatted according to the given pattern.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> format_datetime(dt, locale='en_US')
+    u'Apr 1, 2007, 3:30:00\u202fPM'
+
+    For any pattern requiring the display of the timezone:
+
+    >>> format_datetime(dt, 'full', tzinfo=get_timezone('Europe/Paris'),
+    ...                 locale='fr_FR')
+    'dimanche 1 avril 2007, 17:30:00 heure d’été d’Europe centrale'
+    >>> format_datetime(dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
+    ...                 tzinfo=get_timezone('US/Eastern'), locale='en')
+    u'2007.04.01 AD at 11:30:00 EDT'
+
+    :param datetime: the `datetime` object; if `None`, the current date and
+                     time is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the timezone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime), tzinfo)
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        return get_datetime_format(format, locale=locale) \
+            .replace("'", "") \
+            .replace('{0}', format_time(datetime, format, tzinfo=None,
+                                        locale=locale)) \
+            .replace('{1}', format_date(datetime, format, locale=locale))
+    else:
+        return parse_pattern(format).apply(datetime, locale)
+
+
+def format_time(
+    time: datetime.time | datetime.datetime | float | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a time formatted according to the given pattern.
+
+    >>> from datetime import datetime, time
+    >>> t = time(15, 30)
+    >>> format_time(t, locale='en_US')
+    u'3:30:00\u202fPM'
+    >>> format_time(t, format='short', locale='de_DE')
+    u'15:30'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom time pattern:
+
+    >>> format_time(t, "hh 'o''clock' a", locale='en')
+    u"03 o'clock PM"
+
+    For any pattern requiring the display of the time-zone a
+    timezone has to be specified explicitly:
+
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> tzinfo = get_timezone('Europe/Paris')
+    >>> t = _localize(tzinfo, t)
+    >>> format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
+    '15:30:00 heure d’été d’Europe centrale'
+    >>> format_time(t, "hh 'o''clock' a, zzzz", tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en')
+    u"09 o'clock AM, Eastern Daylight Time"
+
+    As that example shows, when this function gets passed a
+    ``datetime.datetime`` value, the actual time in the formatted string is
+    adjusted to the timezone specified by the `tzinfo` parameter. If the
+    ``datetime`` is "naive" (i.e. it has no associated timezone information),
+    it is assumed to be in UTC.
+
+    These timezone calculations are **not** performed if the value is of type
+    ``datetime.time``, as without date information there's no way to determine
+    what a given time would translate to in a different timezone without
+    information about whether daylight savings time is in effect or not. This
+    means that time values are left as-is, and the value of the `tzinfo`
+    parameter is only used to display the timezone name if needed:
+
+    >>> t = time(15, 30)
+    >>> format_time(t, format='full', tzinfo=get_timezone('Europe/Paris'),
+    ...             locale='fr_FR')  # doctest: +SKIP
+    u'15:30:00 heure normale d\u2019Europe centrale'
+    >>> format_time(t, format='full', tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en_US')  # doctest: +SKIP
+    u'3:30:00\u202fPM Eastern Standard Time'
+
+    :param time: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the time-zone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+
+    # get reference date for if we need to find the right timezone variant
+    # in the pattern
+    ref_date = time.date() if isinstance(time, datetime.datetime) else None
+
+    time = _get_time(time, tzinfo)
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_time_format(format, locale=locale)
+    return parse_pattern(format).apply(time, locale, reference_date=ref_date)
+
+
+def format_skeleton(
+    skeleton: str,
+    datetime: _Instant = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a time and/or date formatted according to the given pattern.
+
+    The skeletons are defined in the CLDR data and provide more flexibility
+    than the simple short/long/medium formats, but are a bit harder to use.
+    The are defined using the date/time symbols without order or punctuation
+    and map to a suitable format for the given locale.
+
+    >>> from datetime import datetime
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> format_skeleton('MMMEd', t, locale='fr')
+    u'dim. 1 avr.'
+    >>> format_skeleton('MMMEd', t, locale='en')
+    u'Sun, Apr 1'
+    >>> format_skeleton('yMMd', t, locale='fi')  # yMMd is not in the Finnish locale; yMd gets used
+    u'1.4.2007'
+    >>> format_skeleton('yMMd', t, fuzzy=False, locale='fi')  # yMMd is not in the Finnish locale, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: yMMd
+    >>> format_skeleton('GH', t, fuzzy=True, locale='fi_FI')  # GH is not in the Finnish locale and there is no close match, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: None
+
+    After the skeleton is resolved to a pattern `format_datetime` is called so
+    all timezone processing etc is the same as for that.
+
+    :param skeleton: A date time skeleton as defined in the cldr data.
+    :param datetime: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param tzinfo: the time-zone to apply to the time for display
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it. If there is no close match, a `KeyError`
+                  is thrown.
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    locale = Locale.parse(locale or LC_TIME)
+    if fuzzy and skeleton not in locale.datetime_skeletons:
+        skeleton = match_skeleton(skeleton, locale.datetime_skeletons)
+    format = locale.datetime_skeletons[skeleton]
+    return format_datetime(datetime, format, tzinfo, locale)
+
+
+TIMEDELTA_UNITS: tuple[tuple[str, int], ...] = (
+    ('year', 3600 * 24 * 365),
+    ('month', 3600 * 24 * 30),
+    ('week', 3600 * 24 * 7),
+    ('day', 3600 * 24),
+    ('hour', 3600),
+    ('minute', 60),
+    ('second', 1),
+)
+
+
+def format_timedelta(
+    delta: datetime.timedelta | int,
+    granularity: Literal['year', 'month', 'week', 'day', 'hour', 'minute', 'second'] = 'second',
+    threshold: float = .85,
+    add_direction: bool = False,
+    format: Literal['narrow', 'short', 'medium', 'long'] = 'long',
+    locale: Locale | str | None = None,
+) -> str:
+    """Return a time delta according to the rules of the given locale.
+
+    >>> from datetime import timedelta
+    >>> format_timedelta(timedelta(weeks=12), locale='en_US')
+    u'3 months'
+    >>> format_timedelta(timedelta(seconds=1), locale='es')
+    u'1 segundo'
+
+    The granularity parameter can be provided to alter the lowest unit
+    presented, which defaults to a second.
+
+    >>> format_timedelta(timedelta(hours=3), granularity='day', locale='en_US')
+    u'1 day'
+
+    The threshold parameter can be used to determine at which value the
+    presentation switches to the next higher unit. A higher threshold factor
+    means the presentation will switch later. For example:
+
+    >>> format_timedelta(timedelta(hours=23), threshold=0.9, locale='en_US')
+    u'1 day'
+    >>> format_timedelta(timedelta(hours=23), threshold=1.1, locale='en_US')
+    u'23 hours'
+
+    In addition directional information can be provided that informs
+    the user if the date is in the past or in the future:
+
+    >>> format_timedelta(timedelta(hours=1), add_direction=True, locale='en')
+    u'in 1 hour'
+    >>> format_timedelta(timedelta(hours=-1), add_direction=True, locale='en')
+    u'1 hour ago'
+
+    The format parameter controls how compact or wide the presentation is:
+
+    >>> format_timedelta(timedelta(hours=3), format='short', locale='en')
+    u'3 hr'
+    >>> format_timedelta(timedelta(hours=3), format='narrow', locale='en')
+    u'3h'
+
+    :param delta: a ``timedelta`` object representing the time difference to
+                  format, or the delta in seconds as an `int` value
+    :param granularity: determines the smallest unit that should be displayed,
+                        the value can be one of "year", "month", "week", "day",
+                        "hour", "minute" or "second"
+    :param threshold: factor that determines at which point the presentation
+                      switches to the next higher unit
+    :param add_direction: if this flag is set to `True` the return value will
+                          include directional information.  For instance a
+                          positive timedelta will include the information about
+                          it being in the future, a negative will be information
+                          about the value being in the past.
+    :param format: the format, can be "narrow", "short" or "long". (
+                   "medium" is deprecated, currently converted to "long" to
+                   maintain compatibility)
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    if format not in ('narrow', 'short', 'medium', 'long'):
+        raise TypeError('Format must be one of "narrow", "short" or "long"')
+    if format == 'medium':
+        warnings.warn(
+            '"medium" value for format param of format_timedelta'
+            ' is deprecated. Use "long" instead',
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        format = 'long'
+    if isinstance(delta, datetime.timedelta):
+        seconds = int((delta.days * 86400) + delta.seconds)
+    else:
+        seconds = delta
+    locale = Locale.parse(locale or LC_TIME)
+    date_fields = locale._data["date_fields"]
+    unit_patterns = locale._data["unit_patterns"]
+
+    def _iter_patterns(a_unit):
+        if add_direction:
+            # Try to find the length variant version first ("year-narrow")
+            # before falling back to the default.
+            unit_rel_patterns = (date_fields.get(f"{a_unit}-{format}") or date_fields[a_unit])
+            if seconds >= 0:
+                yield unit_rel_patterns['future']
+            else:
+                yield unit_rel_patterns['past']
+        a_unit = f"duration-{a_unit}"
+        unit_pats = unit_patterns.get(a_unit, {})
+        yield unit_pats.get(format)
+        # We do not support `<alias>` tags at all while ingesting CLDR data,
+        # so these aliases specified in `root.xml` are hard-coded here:
+        # <unitLength type="long"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        # <unitLength type="narrow"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        if format in ("long", "narrow"):
+            yield unit_pats.get("short")
+
+    for unit, secs_per_unit in TIMEDELTA_UNITS:
+        value = abs(seconds) / secs_per_unit
+        if value >= threshold or unit == granularity:
+            if unit == granularity and value > 0:
+                value = max(1, value)
+            value = int(round(value))
+            plural_form = locale.plural_form(value)
+            pattern = None
+            for patterns in _iter_patterns(unit):
+                if patterns is not None:
+                    pattern = patterns.get(plural_form) or patterns.get('other')
+                    if pattern:
+                        break
+            # This really should not happen
+            if pattern is None:
+                return ''
+            return pattern.replace('{0}', str(value))
+
+    return ''
+
+
+def _format_fallback_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None,
+    tzinfo: datetime.tzinfo | None,
+    locale: Locale,
+) -> str:
+    if skeleton in locale.datetime_skeletons:  # Use the given skeleton
+        format = lambda dt: format_skeleton(skeleton, dt, tzinfo, locale=locale)
+    elif all((isinstance(d, datetime.date) and not isinstance(d, datetime.datetime)) for d in (start, end)):  # Both are just dates
+        format = lambda dt: format_date(dt, locale=locale)
+    elif all((isinstance(d, datetime.time) and not isinstance(d, datetime.date)) for d in (start, end)):  # Both are times
+        format = lambda dt: format_time(dt, tzinfo=tzinfo, locale=locale)
+    else:
+        format = lambda dt: format_datetime(dt, tzinfo=tzinfo, locale=locale)
+
+    formatted_start = format(start)
+    formatted_end = format(end)
+
+    if formatted_start == formatted_end:
+        return format(start)
+
+    return (
+        locale.interval_formats.get(None, "{0}-{1}").
+        replace("{0}", formatted_start).
+        replace("{1}", formatted_end)
+    )
+
+
+def format_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Format an interval between two instants according to the locale's rules.
+
+    >>> from datetime import date, time
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "yMd", locale="fi")
+    u'15.\u201317.1.2016'
+
+    >>> format_interval(time(12, 12), time(16, 16), "Hm", locale="en_GB")
+    '12:12\u201316:16'
+
+    >>> format_interval(time(5, 12), time(16, 16), "hm", locale="en_US")
+    '5:12\u202fAM\u2009–\u20094:16\u202fPM'
+
+    >>> format_interval(time(16, 18), time(16, 24), "Hm", locale="it")
+    '16:18\u201316:24'
+
+    If the start instant equals the end instant, the interval is formatted like the instant.
+
+    >>> format_interval(time(16, 18), time(16, 18), "Hm", locale="it")
+    '16:18'
+
+    Unknown skeletons fall back to "default" formatting.
+
+    >>> format_interval(date(2015, 1, 1), date(2017, 1, 1), "wzq", locale="ja")
+    '2015/01/01\uff5e2017/01/01'
+
+    >>> format_interval(time(16, 18), time(16, 24), "xxx", locale="ja")
+    '16:18:00\uff5e16:24:00'
+
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "xxx", locale="de")
+    '15.01.2016\u2009–\u200917.01.2016'
+
+    :param start: First instant (datetime/date/time)
+    :param end: Second instant (datetime/date/time)
+    :param skeleton: The "skeleton format" to use for formatting.
+    :param tzinfo: tzinfo to use (if none is already attached)
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it.
+    :param locale: A locale object or identifier. Defaults to the system time locale.
+    :return: Formatted interval
+    """
+    locale = Locale.parse(locale or LC_TIME)
+
+    # NB: The quote comments below are from the algorithm description in
+    #     https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    # > Look for the intervalFormatItem element that matches the "skeleton",
+    # > starting in the current locale and then following the locale fallback
+    # > chain up to, but not including root.
+
+    interval_formats = locale.interval_formats
+
+    if skeleton not in interval_formats or not skeleton:
+        # > If no match was found from the previous step, check what the closest
+        # > match is in the fallback locale chain, as in availableFormats. That
+        # > is, this allows for adjusting the string value field's width,
+        # > including adjusting between "MMM" and "MMMM", and using different
+        # > variants of the same field, such as 'v' and 'z'.
+        if skeleton and fuzzy:
+            skeleton = match_skeleton(skeleton, interval_formats)
+        else:
+            skeleton = None
+        if not skeleton:  # Still no match whatsoever?
+            # > Otherwise, format the start and end datetime using the fallback pattern.
+            return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+    skel_formats = interval_formats[skeleton]
+
+    if start == end:
+        return format_skeleton(skeleton, start, tzinfo, fuzzy=fuzzy, locale=locale)
+
+    start = _ensure_datetime_tzinfo(_get_datetime(start), tzinfo=tzinfo)
+    end = _ensure_datetime_tzinfo(_get_datetime(end), tzinfo=tzinfo)
+
+    start_fmt = DateTimeFormat(start, locale=locale)
+    end_fmt = DateTimeFormat(end, locale=locale)
+
+    # > If a match is found from previous steps, compute the calendar field
+    # > with the greatest difference between start and end datetime. If there
+    # > is no difference among any of the fields in the pattern, format as a
+    # > single date using availableFormats, and return.
+
+    for field in PATTERN_CHAR_ORDER:  # These are in largest-to-smallest order
+        if field in skel_formats and start_fmt.extract(field) != end_fmt.extract(field):
+            # > If there is a match, use the pieces of the corresponding pattern to
+            # > format the start and end datetime, as above.
+            return "".join(
+                parse_pattern(pattern).apply(instant, locale)
+                for pattern, instant
+                in zip(skel_formats[field], (start, end))
+            )
+
+    # > Otherwise, format the start and end datetime using the fallback pattern.
+
+    return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+
+def get_period_id(
+    time: _Instant,
+    tzinfo: datetime.tzinfo | None = None,
+    type: Literal['selection'] | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Get the day period ID for a given time.
+
+    This ID can be used as a key for the period name dictionary.
+
+    >>> from datetime import time
+    >>> get_period_names(locale="de")[get_period_id(time(7, 42), locale="de")]
+    u'Morgen'
+
+    >>> get_period_id(time(0), locale="en_US")
+    u'midnight'
+
+    >>> get_period_id(time(0), type="selection", locale="en_US")
+    u'night1'
+
+    :param time: The time to inspect.
+    :param tzinfo: The timezone for the time. See ``format_time``.
+    :param type: The period type to use. Either "selection" or None.
+                 The selection type is used for selecting among phrases such as
+                 “Your email arrived yesterday evening” or “Your email arrived last night”.
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :return: period ID. Something is always returned -- even if it's just "am" or "pm".
+    """
+    time = _get_time(time, tzinfo)
+    seconds_past_midnight = int(time.hour * 60 * 60 + time.minute * 60 + time.second)
+    locale = Locale.parse(locale or LC_TIME)
+
+    # The LDML rules state that the rules may not overlap, so iterating in arbitrary
+    # order should be alright, though `at` periods should be preferred.
+    rulesets = locale.day_period_rules.get(type, {}).items()
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "at" in rule and rule["at"] == seconds_past_midnight:
+                return rule_id
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "from" in rule and "before" in rule:
+                if rule["from"] < rule["before"]:
+                    if rule["from"] <= seconds_past_midnight < rule["before"]:
+                        return rule_id
+                else:
+                    # e.g. from="21:00" before="06:00"
+                    if rule["from"] <= seconds_past_midnight < 86400 or \
+                            0 <= seconds_past_midnight < rule["before"]:
+                        return rule_id
+
+            start_ok = end_ok = False
+
+            if "from" in rule and seconds_past_midnight >= rule["from"]:
+                start_ok = True
+            if "to" in rule and seconds_past_midnight <= rule["to"]:
+                # This rule type does not exist in the present CLDR data;
+                # excuse the lack of test coverage.
+                end_ok = True
+            if "before" in rule and seconds_past_midnight < rule["before"]:
+                end_ok = True
+            if "after" in rule:
+                raise NotImplementedError("'after' is deprecated as of CLDR 29.")
+
+            if start_ok and end_ok:
+                return rule_id
+
+    if seconds_past_midnight < 43200:
+        return "am"
+    else:
+        return "pm"
+
+
+class ParseError(ValueError):
+    pass
+
+
+def parse_date(
+    string: str,
+    locale: Locale | str | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+) -> datetime.date:
+    """Parse a date from a string.
+
+    If an explicit format is provided, it is used to parse the date.
+
+    >>> parse_date('01.04.2004', format='dd.MM.yyyy')
+    datetime.date(2004, 4, 1)
+
+    If no format is given, or if it is one of "full", "long", "medium",
+    or "short", the function first tries to interpret the string as
+    ISO-8601 date format and then uses the date format for the locale
+    as a hint to determine the order in which the date fields appear in
+    the string.
+
+    >>> parse_date('4/1/04', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('01.04.2004', locale='de_DE')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='de_DE')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('01.04.04', locale='de_DE', format='short')
+    datetime.date(2004, 4, 1)
+
+    :param string: the string containing the date
+    :param locale: a `Locale` object or a locale identifier
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    :param format: the format to use, either an explicit date format,
+                   or one of "full", "long", "medium", or "short"
+                   (see ``get_time_format``)
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    use_predefined_format = format in ('full', 'long', 'medium', 'short')
+    # we try ISO-8601 format first, meaning similar to formats
+    # extended YYYY-MM-DD or basic YYYYMMDD
+    iso_alike = re.match(r'^(\d{4})-?([01]\d)-?([0-3]\d)$',
+                         string, flags=re.ASCII)  # allow only ASCII digits
+    if iso_alike and use_predefined_format:
+        try:
+            return datetime.date(*map(int, iso_alike.groups()))
+        except ValueError:
+            pass  # a locale format might fit better, so let's continue
+
+    if use_predefined_format:
+        fmt = get_date_format(format=format, locale=locale)
+    else:
+        fmt = parse_pattern(format)
+    format_str = fmt.pattern.lower()
+    year_idx = format_str.index('y')
+    month_idx = format_str.find('m')
+    if month_idx < 0:
+        month_idx = format_str.index('l')
+    day_idx = format_str.index('d')
+
+    indexes = sorted([(year_idx, 'Y'), (month_idx, 'M'), (day_idx, 'D')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # FIXME: this currently only supports numbers, but should also support month
+    #        names, both in the requested locale, and english
+
+    year = numbers[indexes['Y']]
+    year = 2000 + int(year) if len(year) == 2 else int(year)
+    month = int(numbers[indexes['M']])
+    day = int(numbers[indexes['D']])
+    if month > 12:
+        month, day = day, month
+    return datetime.date(year, month, day)
+
+
+def parse_time(
+    string: str,
+    locale: Locale | str | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+) -> datetime.time:
+    """Parse a time from a string.
+
+    This function uses the time format for the locale as a hint to determine
+    the order in which the time fields appear in the string.
+
+    If an explicit format is provided, the function will use it to parse
+    the time instead.
+
+    >>> parse_time('15:30:00', locale='en_US')
+    datetime.time(15, 30)
+    >>> parse_time('15:30:00', format='H:mm:ss')
+    datetime.time(15, 30)
+
+    :param string: the string containing the time
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    :param format: the format to use, either an explicit time format,
+                   or one of "full", "long", "medium", or "short"
+                   (see ``get_time_format``)
+    :return: the parsed time
+    :rtype: `time`
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    # TODO: try ISO format first?
+    if format in ('full', 'long', 'medium', 'short'):
+        fmt = get_time_format(format=format, locale=locale)
+    else:
+        fmt = parse_pattern(format)
+    format_str = fmt.pattern.lower()
+    hour_idx = format_str.find('h')
+    if hour_idx < 0:
+        hour_idx = format_str.index('k')
+    min_idx = format_str.index('m')
+    # format might not contain seconds
+    if (sec_idx := format_str.find('s')) < 0:
+        sec_idx = math.inf
+
+    indexes = sorted([(hour_idx, 'H'), (min_idx, 'M'), (sec_idx, 'S')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # TODO: support time zones
+
+    # Check if the format specifies a period to be used;
+    # if it does, look for 'pm' to figure out an offset.
+    hour_offset = 0
+    if 'a' in format_str and 'pm' in string.lower():
+        hour_offset = 12
+
+    # Parse up to three numbers from the string.
+    minute = second = 0
+    hour = int(numbers[indexes['H']]) + hour_offset
+    if len(numbers) > 1:
+        minute = int(numbers[indexes['M']])
+        if len(numbers) > 2:
+            second = int(numbers[indexes['S']])
+    return datetime.time(hour, minute, second)
+
+
+class DateTimePattern:
+
+    def __init__(self, pattern: str, format: DateTimeFormat):
+        self.pattern = pattern
+        self.format = format
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.pattern!r}>"
+
+    def __str__(self) -> str:
+        pat = self.pattern
+        return pat
+
+    def __mod__(self, other: DateTimeFormat) -> str:
+        if not isinstance(other, DateTimeFormat):
+            return NotImplemented
+        return self.format % other
+
+    def apply(
+        self,
+        datetime: datetime.date | datetime.time,
+        locale: Locale | str | None,
+        reference_date: datetime.date | None = None,
+    ) -> str:
+        return self % DateTimeFormat(datetime, locale, reference_date)
+
+
+class DateTimeFormat:
+
+    def __init__(
+        self,
+        value: datetime.date | datetime.time,
+        locale: Locale | str,
+        reference_date: datetime.date | None = None,
+    ) -> None:
+        assert isinstance(value, (datetime.date, datetime.datetime, datetime.time))
+        if isinstance(value, (datetime.datetime, datetime.time)) and value.tzinfo is None:
+            value = value.replace(tzinfo=UTC)
+        self.value = value
+        self.locale = Locale.parse(locale)
+        self.reference_date = reference_date
+
+    def __getitem__(self, name: str) -> str:
+        char = name[0]
+        num = len(name)
+        if char == 'G':
+            return self.format_era(char, num)
+        elif char in ('y', 'Y', 'u'):
+            return self.format_year(char, num)
+        elif char in ('Q', 'q'):
+            return self.format_quarter(char, num)
+        elif char in ('M', 'L'):
+            return self.format_month(char, num)
+        elif char in ('w', 'W'):
+            return self.format_week(char, num)
+        elif char == 'd':
+            return self.format(self.value.day, num)
+        elif char == 'D':
+            return self.format_day_of_year(num)
+        elif char == 'F':
+            return self.format_day_of_week_in_month()
+        elif char in ('E', 'e', 'c'):
+            return self.format_weekday(char, num)
+        elif char in ('a', 'b', 'B'):
+            return self.format_period(char, num)
+        elif char == 'h':
+            if self.value.hour % 12 == 0:
+                return self.format(12, num)
+            else:
+                return self.format(self.value.hour % 12, num)
+        elif char == 'H':
+            return self.format(self.value.hour, num)
+        elif char == 'K':
+            return self.format(self.value.hour % 12, num)
+        elif char == 'k':
+            if self.value.hour == 0:
+                return self.format(24, num)
+            else:
+                return self.format(self.value.hour, num)
+        elif char == 'm':
+            return self.format(self.value.minute, num)
+        elif char == 's':
+            return self.format(self.value.second, num)
+        elif char == 'S':
+            return self.format_frac_seconds(num)
+        elif char == 'A':
+            return self.format_milliseconds_in_day(num)
+        elif char in ('z', 'Z', 'v', 'V', 'x', 'X', 'O'):
+            return self.format_timezone(char, num)
+        else:
+            raise KeyError(f"Unsupported date/time field {char!r}")
+
+    def extract(self, char: str) -> int:
+        char = str(char)[0]
+        if char == 'y':
+            return self.value.year
+        elif char == 'M':
+            return self.value.month
+        elif char == 'd':
+            return self.value.day
+        elif char == 'H':
+            return self.value.hour
+        elif char == 'h':
+            return self.value.hour % 12 or 12
+        elif char == 'm':
+            return self.value.minute
+        elif char == 'a':
+            return int(self.value.hour >= 12)  # 0 for am, 1 for pm
+        else:
+            raise NotImplementedError(f"Not implemented: extracting {char!r} from {self.value!r}")
+
+    def format_era(self, char: str, num: int) -> str:
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)]
+        era = int(self.value.year >= 0)
+        return get_era_names(width, self.locale)[era]
+
+    def format_year(self, char: str, num: int) -> str:
+        value = self.value.year
+        if char.isupper():
+            month = self.value.month
+            if month == 1 and self.value.day < 7 and self.get_week_of_year() >= 52:
+                value -= 1
+            elif month == 12 and self.value.day > 25 and self.get_week_of_year() <= 2:
+                value += 1
+        year = self.format(value, num)
+        if num == 2:
+            year = year[-2:]
+        return year
+
+    def format_quarter(self, char: str, num: int) -> str:
+        quarter = (self.value.month - 1) // 3 + 1
+        if num <= 2:
+            return '%0*d' % (num, quarter)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'Q': 'format', 'q': 'stand-alone'}[char]
+        return get_quarter_names(width, context, self.locale)[quarter]
+
+    def format_month(self, char: str, num: int) -> str:
+        if num <= 2:
+            return '%0*d' % (num, self.value.month)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'M': 'format', 'L': 'stand-alone'}[char]
+        return get_month_names(width, context, self.locale)[self.value.month]
+
+    def format_week(self, char: str, num: int) -> str:
+        if char.islower():  # week of year
+            week = self.get_week_of_year()
+            return self.format(week, num)
+        else:  # week of month
+            week = self.get_week_of_month()
+            return str(week)
+
+    def format_weekday(self, char: str = 'E', num: int = 4) -> str:
+        """
+        Return weekday from parsed datetime according to format pattern.
+
+        >>> from datetime import date
+        >>> format = DateTimeFormat(date(2016, 2, 28), Locale.parse('en_US'))
+        >>> format.format_weekday()
+        u'Sunday'
+
+        'E': Day of week - Use one through three letters for the abbreviated day name, four for the full (wide) name,
+             five for the narrow name, or six for the short name.
+        >>> format.format_weekday('E',2)
+        u'Sun'
+
+        'e': Local day of week. Same as E except adds a numeric value that will depend on the local starting day of the
+             week, using one or two letters. For this example, Monday is the first day of the week.
+        >>> format.format_weekday('e',2)
+        '01'
+
+        'c': Stand-Alone local day of week - Use one letter for the local numeric value (same as 'e'), three for the
+             abbreviated day name, four for the full (wide) name, five for the narrow name, or six for the short name.
+        >>> format.format_weekday('c',1)
+        '1'
+
+        :param char: pattern format character ('e','E','c')
+        :param num: count of format character
+
+        """
+        if num < 3:
+            if char.islower():
+                value = 7 - self.locale.first_week_day + self.value.weekday()
+                return self.format(value % 7 + 1, num)
+            num = 3
+        weekday = self.value.weekday()
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow', 6: 'short'}[num]
+        context = "stand-alone" if char == "c" else "format"
+        return get_day_names(width, context, self.locale)[weekday]
+
+    def format_day_of_year(self, num: int) -> str:
+        return self.format(self.get_day_of_year(), num)
+
+    def format_day_of_week_in_month(self) -> str:
+        return str((self.value.day - 1) // 7 + 1)
+
+    def format_period(self, char: str, num: int) -> str:
+        """
+        Return period from parsed datetime according to format pattern.
+
+        >>> from datetime import datetime, time
+        >>> format = DateTimeFormat(time(13, 42), 'fi_FI')
+        >>> format.format_period('a', 1)
+        u'ip.'
+        >>> format.format_period('b', 1)
+        u'iltap.'
+        >>> format.format_period('b', 4)
+        u'iltapäivä'
+        >>> format.format_period('B', 4)
+        u'iltapäivällä'
+        >>> format.format_period('B', 5)
+        u'ip.'
+
+        >>> format = DateTimeFormat(datetime(2022, 4, 28, 6, 27), 'zh_Hant')
+        >>> format.format_period('a', 1)
+        u'上午'
+        >>> format.format_period('B', 1)
+        u'清晨'
+
+        :param char: pattern format character ('a', 'b', 'B')
+        :param num: count of format character
+
+        """
+        widths = [{3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)],
+                  'wide', 'narrow', 'abbreviated']
+        if char == 'a':
+            period = 'pm' if self.value.hour >= 12 else 'am'
+            context = 'format'
+        else:
+            period = get_period_id(self.value, locale=self.locale)
+            context = 'format' if char == 'B' else 'stand-alone'
+        for width in widths:
+            period_names = get_period_names(context=context, width=width, locale=self.locale)
+            if period in period_names:
+                return period_names[period]
+        raise ValueError(f"Could not format period {period} in {self.locale}")
+
+    def format_frac_seconds(self, num: int) -> str:
+        """ Return fractional seconds.
+
+        Rounds the time's microseconds to the precision given by the number \
+        of digits passed in.
+        """
+        value = self.value.microsecond / 1000000
+        return self.format(round(value, num) * 10**num, num)
+
+    def format_milliseconds_in_day(self, num):
+        msecs = self.value.microsecond // 1000 + self.value.second * 1000 + \
+            self.value.minute * 60000 + self.value.hour * 3600000
+        return self.format(msecs, num)
+
+    def format_timezone(self, char: str, num: int) -> str:
+        width = {3: 'short', 4: 'long', 5: 'iso8601'}[max(3, num)]
+
+        # It could be that we only receive a time to format, but also have a
+        # reference date which is important to distinguish between timezone
+        # variants (summer/standard time)
+        value = self.value
+        if self.reference_date:
+            value = datetime.datetime.combine(self.reference_date, self.value)
+
+        if char == 'z':
+            return get_timezone_name(value, width, locale=self.locale)
+        elif char == 'Z':
+            if num == 5:
+                return get_timezone_gmt(value, width, locale=self.locale, return_z=True)
+            return get_timezone_gmt(value, width, locale=self.locale)
+        elif char == 'O':
+            if num == 4:
+                return get_timezone_gmt(value, width, locale=self.locale)
+        # TODO: To add support for O:1
+        elif char == 'v':
+            return get_timezone_name(value.tzinfo, width,
+                                     locale=self.locale)
+        elif char == 'V':
+            if num == 1:
+                return get_timezone_name(value.tzinfo, width,
+                                         uncommon=True, locale=self.locale)
+            elif num == 2:
+                return get_timezone_name(value.tzinfo, locale=self.locale, return_zone=True)
+            elif num == 3:
+                return get_timezone_location(value.tzinfo, locale=self.locale, return_city=True)
+            return get_timezone_location(value.tzinfo, locale=self.locale)
+        # Included additional elif condition to add support for 'Xx' in timezone format
+        elif char == 'X':
+            if num == 1:
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale,
+                                        return_z=True)
+            elif num in (2, 4):
+                return get_timezone_gmt(value, width='short', locale=self.locale,
+                                        return_z=True)
+            elif num in (3, 5):
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale,
+                                        return_z=True)
+        elif char == 'x':
+            if num == 1:
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale)
+            elif num in (2, 4):
+                return get_timezone_gmt(value, width='short', locale=self.locale)
+            elif num in (3, 5):
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale)
+
+    def format(self, value: SupportsInt, length: int) -> str:
+        return '%0*d' % (length, value)
+
+    def get_day_of_year(self, date: datetime.date | None = None) -> int:
+        if date is None:
+            date = self.value
+        return (date - date.replace(month=1, day=1)).days + 1
+
+    def get_week_of_year(self) -> int:
+        """Return the week of the year."""
+        day_of_year = self.get_day_of_year(self.value)
+        week = self.get_week_number(day_of_year)
+        if week == 0:
+            date = datetime.date(self.value.year - 1, 12, 31)
+            week = self.get_week_number(self.get_day_of_year(date),
+                                        date.weekday())
+        elif week > 52:
+            weekday = datetime.date(self.value.year + 1, 1, 1).weekday()
+            if self.get_week_number(1, weekday) == 1 and \
+                    32 - (weekday - self.locale.first_week_day) % 7 <= self.value.day:
+                week = 1
+        return week
+
+    def get_week_of_month(self) -> int:
+        """Return the week of the month."""
+        return self.get_week_number(self.value.day)
+
+    def get_week_number(self, day_of_period: int, day_of_week: int | None = None) -> int:
+        """Return the number of the week of a day within a period. This may be
+        the week number in a year or the week number in a month.
+
+        Usually this will return a value equal to or greater than 1, but if the
+        first week of the period is so short that it actually counts as the last
+        week of the previous period, this function will return 0.
+
+        >>> date = datetime.date(2006, 1, 8)
+        >>> DateTimeFormat(date, 'de_DE').get_week_number(6)
+        1
+        >>> DateTimeFormat(date, 'en_US').get_week_number(6)
+        2
+
+        :param day_of_period: the number of the day in the period (usually
+                              either the day of month or the day of year)
+        :param day_of_week: the week day; if omitted, the week day of the
+                            current date is assumed
+        """
+        if day_of_week is None:
+            day_of_week = self.value.weekday()
+        first_day = (day_of_week - self.locale.first_week_day -
+                     day_of_period + 1) % 7
+        if first_day < 0:
+            first_day += 7
+        week_number = (day_of_period + first_day - 1) // 7
+        if 7 - first_day >= self.locale.min_week_days:
+            week_number += 1
+        return week_number
+
+
+PATTERN_CHARS: dict[str, list[int] | None] = {
+    'G': [1, 2, 3, 4, 5],                                               # era
+    'y': None, 'Y': None, 'u': None,                                    # year
+    'Q': [1, 2, 3, 4, 5], 'q': [1, 2, 3, 4, 5],                         # quarter
+    'M': [1, 2, 3, 4, 5], 'L': [1, 2, 3, 4, 5],                         # month
+    'w': [1, 2], 'W': [1],                                              # week
+    'd': [1, 2], 'D': [1, 2, 3], 'F': [1], 'g': None,                   # day
+    'E': [1, 2, 3, 4, 5, 6], 'e': [1, 2, 3, 4, 5, 6], 'c': [1, 3, 4, 5, 6],  # week day
+    'a': [1, 2, 3, 4, 5], 'b': [1, 2, 3, 4, 5], 'B': [1, 2, 3, 4, 5],   # period
+    'h': [1, 2], 'H': [1, 2], 'K': [1, 2], 'k': [1, 2],                 # hour
+    'm': [1, 2],                                                        # minute
+    's': [1, 2], 'S': None, 'A': None,                                  # second
+    'z': [1, 2, 3, 4], 'Z': [1, 2, 3, 4, 5], 'O': [1, 4], 'v': [1, 4],  # zone
+    'V': [1, 2, 3, 4], 'x': [1, 2, 3, 4, 5], 'X': [1, 2, 3, 4, 5],      # zone
+}
+
+#: The pattern characters declared in the Date Field Symbol Table
+#: (https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
+#: in order of decreasing magnitude.
+PATTERN_CHAR_ORDER = "GyYuUQqMLlwWdDFgEecabBChHKkjJmsSAzZOvVXx"
+
+
+def parse_pattern(pattern: str | DateTimePattern) -> DateTimePattern:
+    """Parse date, time, and datetime format patterns.
+
+    >>> parse_pattern("MMMMd").format
+    u'%(MMMM)s%(d)s'
+    >>> parse_pattern("MMM d, yyyy").format
+    u'%(MMM)s %(d)s, %(yyyy)s'
+
+    Pattern can contain literal strings in single quotes:
+
+    >>> parse_pattern("H:mm' Uhr 'z").format
+    u'%(H)s:%(mm)s Uhr %(z)s'
+
+    An actual single quote can be used by using two adjacent single quote
+    characters:
+
+    >>> parse_pattern("hh' o''clock'").format
+    u"%(hh)s o'clock"
+
+    :param pattern: the formatting pattern to parse
+    """
+    if isinstance(pattern, DateTimePattern):
+        return pattern
+    return _cached_parse_pattern(pattern)
+
+
+@lru_cache(maxsize=1024)
+def _cached_parse_pattern(pattern: str) -> DateTimePattern:
+    result = []
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "chars":
+            result.append(tok_value.replace('%', '%%'))
+        elif tok_type == "field":
+            fieldchar, fieldnum = tok_value
+            limit = PATTERN_CHARS[fieldchar]
+            if limit and fieldnum not in limit:
+                raise ValueError(f"Invalid length for field: {fieldchar * fieldnum!r}")
+            result.append('%%(%s)s' % (fieldchar * fieldnum))
+        else:
+            raise NotImplementedError(f"Unknown token type: {tok_type}")
+    return DateTimePattern(pattern, ''.join(result))
+
+
+def tokenize_pattern(pattern: str) -> list[tuple[str, str | tuple[str, int]]]:
+    """
+    Tokenize date format patterns.
+
+    Returns a list of (token_type, token_value) tuples.
+
+    ``token_type`` may be either "chars" or "field".
+
+    For "chars" tokens, the value is the literal value.
+
+    For "field" tokens, the value is a tuple of (field character, repetition count).
+
+    :param pattern: Pattern string
+    :type pattern: str
+    :rtype: list[tuple]
+    """
+    result = []
+    quotebuf = None
+    charbuf = []
+    fieldchar = ['']
+    fieldnum = [0]
+
+    def append_chars():
+        result.append(('chars', ''.join(charbuf).replace('\0', "'")))
+        del charbuf[:]
+
+    def append_field():
+        result.append(('field', (fieldchar[0], fieldnum[0])))
+        fieldchar[0] = ''
+        fieldnum[0] = 0
+
+    for char in pattern.replace("''", '\0'):
+        if quotebuf is None:
+            if char == "'":  # quote started
+                if fieldchar[0]:
+                    append_field()
+                elif charbuf:
+                    append_chars()
+                quotebuf = []
+            elif char in PATTERN_CHARS:
+                if charbuf:
+                    append_chars()
+                if char == fieldchar[0]:
+                    fieldnum[0] += 1
+                else:
+                    if fieldchar[0]:
+                        append_field()
+                    fieldchar[0] = char
+                    fieldnum[0] = 1
+            else:
+                if fieldchar[0]:
+                    append_field()
+                charbuf.append(char)
+
+        elif quotebuf is not None:
+            if char == "'":  # end of quote
+                charbuf.extend(quotebuf)
+                quotebuf = None
+            else:  # inside quote
+                quotebuf.append(char)
+
+    if fieldchar[0]:
+        append_field()
+    elif charbuf:
+        append_chars()
+
+    return result
+
+
+def untokenize_pattern(tokens: Iterable[tuple[str, str | tuple[str, int]]]) -> str:
+    """
+    Turn a date format pattern token stream back into a string.
+
+    This is the reverse operation of ``tokenize_pattern``.
+
+    :type tokens: Iterable[tuple]
+    :rtype: str
+    """
+    output = []
+    for tok_type, tok_value in tokens:
+        if tok_type == "field":
+            output.append(tok_value[0] * tok_value[1])
+        elif tok_type == "chars":
+            if not any(ch in PATTERN_CHARS for ch in tok_value):  # No need to quote
+                output.append(tok_value)
+            else:
+                output.append("'%s'" % tok_value.replace("'", "''"))
+    return "".join(output)
+
+
+def split_interval_pattern(pattern: str) -> list[str]:
+    """
+    Split an interval-describing datetime pattern into multiple pieces.
+
+    > The pattern is then designed to be broken up into two pieces by determining the first repeating field.
+    - https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    >>> split_interval_pattern(u'E d.M. \u2013 E d.M.')
+    [u'E d.M. \u2013 ', 'E d.M.']
+    >>> split_interval_pattern("Y 'text' Y 'more text'")
+    ["Y 'text '", "Y 'more text'"]
+    >>> split_interval_pattern(u"E, MMM d \u2013 E")
+    [u'E, MMM d \u2013 ', u'E']
+    >>> split_interval_pattern("MMM d")
+    ['MMM d']
+    >>> split_interval_pattern("y G")
+    ['y G']
+    >>> split_interval_pattern(u"MMM d \u2013 d")
+    [u'MMM d \u2013 ', u'd']
+
+    :param pattern: Interval pattern string
+    :return: list of "subpatterns"
+    """
+
+    seen_fields = set()
+    parts = [[]]
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "field":
+            if tok_value[0] in seen_fields:  # Repeated field
+                parts.append([])
+                seen_fields.clear()
+            seen_fields.add(tok_value[0])
+        parts[-1].append((tok_type, tok_value))
+
+    return [untokenize_pattern(tokens) for tokens in parts]
+
+
+def match_skeleton(skeleton: str, options: Iterable[str], allow_different_fields: bool = False) -> str | None:
+    """
+    Find the closest match for the given datetime skeleton among the options given.
+
+    This uses the rules outlined in the TR35 document.
+
+    >>> match_skeleton('yMMd', ('yMd', 'yMMMd'))
+    'yMd'
+
+    >>> match_skeleton('yMMd', ('jyMMd',), allow_different_fields=True)
+    'jyMMd'
+
+    >>> match_skeleton('yMMd', ('qyMMd',), allow_different_fields=False)
+
+    >>> match_skeleton('hmz', ('hmv',))
+    'hmv'
+
+    :param skeleton: The skeleton to match
+    :type skeleton: str
+    :param options: An iterable of other skeletons to match against
+    :type options: Iterable[str]
+    :param allow_different_fields: Whether to allow a match that uses different fields
+                                   than the skeleton requested.
+    :type allow_different_fields: bool
+
+    :return: The closest skeleton match, or if no match was found, None.
+    :rtype: str|None
+    """
+
+    # TODO: maybe implement pattern expansion?
+
+    # Based on the implementation in
+    # https://github.com/unicode-org/icu/blob/main/icu4j/main/core/src/main/java/com/ibm/icu/text/DateIntervalInfo.java
+
+    # Filter out falsy values and sort for stability; when `interval_formats` is passed in, there may be a None key.
+    options = sorted(option for option in options if option)
+
+    if 'z' in skeleton and not any('z' in option for option in options):
+        skeleton = skeleton.replace('z', 'v')
+    if 'k' in skeleton and not any('k' in option for option in options):
+        skeleton = skeleton.replace('k', 'H')
+    if 'K' in skeleton and not any('K' in option for option in options):
+        skeleton = skeleton.replace('K', 'h')
+    if 'a' in skeleton and not any('a' in option for option in options):
+        skeleton = skeleton.replace('a', '')
+    if 'b' in skeleton and not any('b' in option for option in options):
+        skeleton = skeleton.replace('b', '')
+
+    get_input_field_width = dict(t[1] for t in tokenize_pattern(skeleton) if t[0] == "field").get
+    best_skeleton = None
+    best_distance = None
+    for option in options:
+        get_opt_field_width = dict(t[1] for t in tokenize_pattern(option) if t[0] == "field").get
+        distance = 0
+        for field in PATTERN_CHARS:
+            input_width = get_input_field_width(field, 0)
+            opt_width = get_opt_field_width(field, 0)
+            if input_width == opt_width:
+                continue
+            if opt_width == 0 or input_width == 0:
+                if not allow_different_fields:  # This one is not okay
+                    option = None
+                    break
+                distance += 0x1000  # Magic weight constant for "entirely different fields"
+            elif field == 'M' and ((input_width > 2 and opt_width <= 2) or (input_width <= 2 and opt_width > 2)):
+                distance += 0x100  # Magic weight for "text turns into a number"
+            else:
+                distance += abs(input_width - opt_width)
+
+        if not option:  # We lost the option along the way (probably due to "allow_different_fields")
+            continue
+
+        if not best_skeleton or distance < best_distance:
+            best_skeleton = option
+            best_distance = distance
+
+        if distance == 0:  # Found a perfect match!
+            break
+
+    return best_skeleton

rtme/lib/python3.10/site-packages/babel/locale-data/LICENSE.unicode

@@ -0,0 +1,41 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 2004-2025 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0