Add files using upload-large-folder tool

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/completion/zsh.completion

@@ -0,0 +1,33 @@
+# Invoke tab-completion script to be sourced with the Z shell.
+# Known to work on zsh 5.0.x, probably works on later 4.x releases as well (as
+# it uses the older compctl completion system).
+
+_complete_{binary}() {{
+    # `words` contains the entire command string up til now (including
+    # program name).
+    #
+    # We hand it to Invoke so it can figure out the current context: spit back
+    # core options, task names, the current task's options, or some combo.
+    #
+    # Before doing so, we attempt to tease out any collection flag+arg so we
+    # can ensure it is applied correctly.
+    collection_arg=''
+    if [[ "${{words}}" =~ "(-c|--collection) [^ ]+" ]]; then
+        collection_arg=$MATCH
+    fi
+    # `reply` is the array of valid completions handed back to `compctl`.
+    # Use ${{=...}} to force whitespace splitting in expansion of
+    # $collection_arg
+    reply=( $({binary} ${{=collection_arg}} --complete -- ${{words}}) )
+}}
+
+
+# Tell shell builtin to use the above for completing our given binary name(s).
+# * -K: use given function name to generate completions.
+# * +: specifies 'alternative' completion, where options after the '+' are only
+#   used if the completion from the options before the '+' result in no matches.
+# * -f: when function generates no results, use filenames.
+# * positional args: program names to complete for.
+compctl -K _complete_{binary} + -f {spaced_names}
+
+# vim: set ft=sh :

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/parser/argument.py

@@ -0,0 +1,178 @@
+from typing import Any, Iterable, Optional, Tuple
+
+# TODO: dynamic type for kind
+# T = TypeVar('T')
+
+
+class Argument:
+    """
+    A command-line argument/flag.
+
+    :param name:
+        Syntactic sugar for ``names=[<name>]``. Giving both ``name`` and
+        ``names`` is invalid.
+    :param names:
+        List of valid identifiers for this argument. For example, a "help"
+        argument may be defined with a name list of ``['-h', '--help']``.
+    :param kind:
+        Type factory & parser hint. E.g. ``int`` will turn the default text
+        value parsed, into a Python integer; and ``bool`` will tell the
+        parser not to expect an actual value but to treat the argument as a
+        toggle/flag.
+    :param default:
+        Default value made available to the parser if no value is given on the
+        command line.
+    :param help:
+        Help text, intended for use with ``--help``.
+    :param positional:
+        Whether or not this argument's value may be given positionally. When
+        ``False`` (default) arguments must be explicitly named.
+    :param optional:
+        Whether or not this (non-``bool``) argument requires a value.
+    :param incrementable:
+        Whether or not this (``int``) argument is to be incremented instead of
+        overwritten/assigned to.
+    :param attr_name:
+        A Python identifier/attribute friendly name, typically filled in with
+        the underscored version when ``name``/``names`` contain dashes.
+
+    .. versionadded:: 1.0
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        names: Iterable[str] = (),
+        kind: Any = str,
+        default: Optional[Any] = None,
+        help: Optional[str] = None,
+        positional: bool = False,
+        optional: bool = False,
+        incrementable: bool = False,
+        attr_name: Optional[str] = None,
+    ) -> None:
+        if name and names:
+            raise TypeError(
+                "Cannot give both 'name' and 'names' arguments! Pick one."
+            )
+        if not (name or names):
+            raise TypeError("An Argument must have at least one name.")
+        if names:
+            self.names = tuple(names)
+        elif name and not names:
+            self.names = (name,)
+        self.kind = kind
+        initial_value: Optional[Any] = None
+        # Special case: list-type args start out as empty list, not None.
+        if kind is list:
+            initial_value = []
+        # Another: incrementable args start out as their default value.
+        if incrementable:
+            initial_value = default
+        self.raw_value = self._value = initial_value
+        self.default = default
+        self.help = help
+        self.positional = positional
+        self.optional = optional
+        self.incrementable = incrementable
+        self.attr_name = attr_name
+
+    def __repr__(self) -> str:
+        nicks = ""
+        if self.nicknames:
+            nicks = " ({})".format(", ".join(self.nicknames))
+        flags = ""
+        if self.positional or self.optional:
+            flags = " "
+        if self.positional:
+            flags += "*"
+        if self.optional:
+            flags += "?"
+        # TODO: store this default value somewhere other than signature of
+        # Argument.__init__?
+        kind = ""
+        if self.kind != str:
+            kind = " [{}]".format(self.kind.__name__)
+        return "<{}: {}{}{}{}>".format(
+            self.__class__.__name__, self.name, nicks, kind, flags
+        )
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        The canonical attribute-friendly name for this argument.
+
+        Will be ``attr_name`` (if given to constructor) or the first name in
+        ``names`` otherwise.
+
+        .. versionadded:: 1.0
+        """
+        return self.attr_name or self.names[0]
+
+    @property
+    def nicknames(self) -> Tuple[str, ...]:
+        return self.names[1:]
+
+    @property
+    def takes_value(self) -> bool:
+        if self.kind is bool:
+            return False
+        if self.incrementable:
+            return False
+        return True
+
+    @property
+    def value(self) -> Any:
+        # TODO: should probably be optional instead
+        return self._value if self._value is not None else self.default
+
+    @value.setter
+    def value(self, arg: str) -> None:
+        self.set_value(arg, cast=True)
+
+    def set_value(self, value: Any, cast: bool = True) -> None:
+        """
+        Actual explicit value-setting API call.
+
+        Sets ``self.raw_value`` to ``value`` directly.
+
+        Sets ``self.value`` to ``self.kind(value)``, unless:
+
+        - ``cast=False``, in which case the raw value is also used.
+        - ``self.kind==list``, in which case the value is appended to
+          ``self.value`` instead of cast & overwritten.
+        - ``self.incrementable==True``, in which case the value is ignored and
+          the current (assumed int) value is simply incremented.
+
+        .. versionadded:: 1.0
+        """
+        self.raw_value = value
+        # Default to do-nothing/identity function
+        func = lambda x: x
+        # If cast, set to self.kind, which should be str/int/etc
+        if cast:
+            func = self.kind
+        # If self.kind is a list, append instead of using cast func.
+        if self.kind is list:
+            func = lambda x: self.value + [x]
+        # If incrementable, just increment.
+        if self.incrementable:
+            # TODO: explode nicely if self.value was not an int to start
+            # with
+            func = lambda x: self.value + 1
+        self._value = func(value)
+
+    @property
+    def got_value(self) -> bool:
+        """
+        Returns whether the argument was ever given a (non-default) value.
+
+        For most argument kinds, this simply checks whether the internally
+        stored value is non-``None``; for others, such as ``list`` kinds,
+        different checks may be used.
+
+        .. versionadded:: 1.3
+        """
+        if self.kind is list:
+            return bool(self._value)
+        return self._value is not None

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/parser/parser.py

@@ -0,0 +1,455 @@
+import copy
+from typing import TYPE_CHECKING, Any, Iterable, List, Optional
+
+try:
+    from ..vendor.lexicon import Lexicon
+    from ..vendor.fluidity import StateMachine, state, transition
+except ImportError:
+    from lexicon import Lexicon  # type: ignore[no-redef]
+    from fluidity import (  # type: ignore[no-redef]
+        StateMachine,
+        state,
+        transition,
+    )
+
+from ..exceptions import ParseError
+from ..util import debug
+
+if TYPE_CHECKING:
+    from .context import ParserContext
+
+
+def is_flag(value: str) -> bool:
+    return value.startswith("-")
+
+
+def is_long_flag(value: str) -> bool:
+    return value.startswith("--")
+
+
+class ParseResult(List["ParserContext"]):
+    """
+    List-like object with some extra parse-related attributes.
+
+    Specifically, a ``.remainder`` attribute, which is the string found after a
+    ``--`` in any parsed argv list; and an ``.unparsed`` attribute, a list of
+    tokens that were unable to be parsed.
+
+    .. versionadded:: 1.0
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.remainder = ""
+        self.unparsed: List[str] = []
+
+
+class Parser:
+    """
+    Create parser conscious of ``contexts`` and optional ``initial`` context.
+
+    ``contexts`` should be an iterable of ``Context`` instances which will be
+    searched when new context names are encountered during a parse. These
+    Contexts determine what flags may follow them, as well as whether given
+    flags take values.
+
+    ``initial`` is optional and will be used to determine validity of "core"
+    options/flags at the start of the parse run, if any are encountered.
+
+    ``ignore_unknown`` determines what to do when contexts are found which do
+    not map to any members of ``contexts``. By default it is ``False``, meaning
+    any unknown contexts result in a parse error exception. If ``True``,
+    encountering an unknown context halts parsing and populates the return
+    value's ``.unparsed`` attribute with the remaining parse tokens.
+
+    .. versionadded:: 1.0
+    """
+
+    def __init__(
+        self,
+        contexts: Iterable["ParserContext"] = (),
+        initial: Optional["ParserContext"] = None,
+        ignore_unknown: bool = False,
+    ) -> None:
+        self.initial = initial
+        self.contexts = Lexicon()
+        self.ignore_unknown = ignore_unknown
+        for context in contexts:
+            debug("Adding {}".format(context))
+            if not context.name:
+                raise ValueError("Non-initial contexts must have names.")
+            exists = "A context named/aliased {!r} is already in this parser!"
+            if context.name in self.contexts:
+                raise ValueError(exists.format(context.name))
+            self.contexts[context.name] = context
+            for alias in context.aliases:
+                if alias in self.contexts:
+                    raise ValueError(exists.format(alias))
+                self.contexts.alias(alias, to=context.name)
+
+    def parse_argv(self, argv: List[str]) -> ParseResult:
+        """
+        Parse an argv-style token list ``argv``.
+
+        Returns a list (actually a subclass, `.ParseResult`) of
+        `.ParserContext` objects matching the order they were found in the
+        ``argv`` and containing `.Argument` objects with updated values based
+        on any flags given.
+
+        Assumes any program name has already been stripped out. Good::
+
+            Parser(...).parse_argv(['--core-opt', 'task', '--task-opt'])
+
+        Bad::
+
+            Parser(...).parse_argv(['invoke', '--core-opt', ...])
+
+        :param argv: List of argument string tokens.
+        :returns:
+            A `.ParseResult` (a ``list`` subclass containing some number of
+            `.ParserContext` objects).
+
+        .. versionadded:: 1.0
+        """
+        machine = ParseMachine(
+            # FIXME: initial should not be none
+            initial=self.initial,  # type: ignore[arg-type]
+            contexts=self.contexts,
+            ignore_unknown=self.ignore_unknown,
+        )
+        # FIXME: Why isn't there str.partition for lists? There must be a
+        # better way to do this. Split argv around the double-dash remainder
+        # sentinel.
+        debug("Starting argv: {!r}".format(argv))
+        try:
+            ddash = argv.index("--")
+        except ValueError:
+            ddash = len(argv)  # No remainder == body gets all
+        body = argv[:ddash]
+        remainder = argv[ddash:][1:]  # [1:] to strip off remainder itself
+        if remainder:
+            debug(
+                "Remainder: argv[{!r}:][1:] => {!r}".format(ddash, remainder)
+            )
+        for index, token in enumerate(body):
+            # Handle non-space-delimited forms, if not currently expecting a
+            # flag value and still in valid parsing territory (i.e. not in
+            # "unknown" state which implies store-only)
+            # NOTE: we do this in a few steps so we can
+            # split-then-check-validity; necessary for things like when the
+            # previously seen flag optionally takes a value.
+            mutations = []
+            orig = token
+            if is_flag(token) and not machine.result.unparsed:
+                # Equals-sign-delimited flags, eg --foo=bar or -f=bar
+                if "=" in token:
+                    token, _, value = token.partition("=")
+                    msg = "Splitting x=y expr {!r} into tokens {!r} and {!r}"
+                    debug(msg.format(orig, token, value))
+                    mutations.append((index + 1, value))
+                # Contiguous boolean short flags, e.g. -qv
+                elif not is_long_flag(token) and len(token) > 2:
+                    full_token = token[:]
+                    rest, token = token[2:], token[:2]
+                    err = "Splitting {!r} into token {!r} and rest {!r}"
+                    debug(err.format(full_token, token, rest))
+                    # Handle boolean flag block vs short-flag + value. Make
+                    # sure not to test the token as a context flag if we've
+                    # passed into 'storing unknown stuff' territory (e.g. on a
+                    # core-args pass, handling what are going to be task args)
+                    have_flag = (
+                        token in machine.context.flags
+                        and machine.current_state != "unknown"
+                    )
+                    if have_flag and machine.context.flags[token].takes_value:
+                        msg = "{!r} is a flag for current context & it takes a value, giving it {!r}"  # noqa
+                        debug(msg.format(token, rest))
+                        mutations.append((index + 1, rest))
+                    else:
+                        _rest = ["-{}".format(x) for x in rest]
+                        msg = "Splitting multi-flag glob {!r} into {!r} and {!r}"  # noqa
+                        debug(msg.format(orig, token, _rest))
+                        for item in reversed(_rest):
+                            mutations.append((index + 1, item))
+            # Here, we've got some possible mutations queued up, and 'token'
+            # may have been overwritten as well. Whether we apply those and
+            # continue as-is, or roll it back, depends:
+            # - If the parser wasn't waiting for a flag value, we're already on
+            # the right track, so apply mutations and move along to the
+            # handle() step.
+            # - If we ARE waiting for a value, and the flag expecting it ALWAYS
+            # wants a value (it's not optional), we go back to using the
+            # original token. (TODO: could reorganize this to avoid the
+            # sub-parsing in this case, but optimizing for human-facing
+            # execution isn't critical.)
+            # - Finally, if we are waiting for a value AND it's optional, we
+            # inspect the first sub-token/mutation to see if it would otherwise
+            # have been a valid flag, and let that determine what we do (if
+            # valid, we apply the mutations; if invalid, we reinstate the
+            # original token.)
+            if machine.waiting_for_flag_value:
+                optional = machine.flag and machine.flag.optional
+                subtoken_is_valid_flag = token in machine.context.flags
+                if not (optional and subtoken_is_valid_flag):
+                    token = orig
+                    mutations = []
+            for index, value in mutations:
+                body.insert(index, value)
+            machine.handle(token)
+        machine.finish()
+        result = machine.result
+        result.remainder = " ".join(remainder)
+        return result
+
+
+class ParseMachine(StateMachine):
+    initial_state = "context"
+
+    state("context", enter=["complete_flag", "complete_context"])
+    state("unknown", enter=["complete_flag", "complete_context"])
+    state("end", enter=["complete_flag", "complete_context"])
+
+    transition(from_=("context", "unknown"), event="finish", to="end")
+    transition(
+        from_="context",
+        event="see_context",
+        action="switch_to_context",
+        to="context",
+    )
+    transition(
+        from_=("context", "unknown"),
+        event="see_unknown",
+        action="store_only",
+        to="unknown",
+    )
+
+    def changing_state(self, from_: str, to: str) -> None:
+        debug("ParseMachine: {!r} => {!r}".format(from_, to))
+
+    def __init__(
+        self,
+        initial: "ParserContext",
+        contexts: Lexicon,
+        ignore_unknown: bool,
+    ) -> None:
+        # Initialize
+        self.ignore_unknown = ignore_unknown
+        self.initial = self.context = copy.deepcopy(initial)
+        debug("Initialized with context: {!r}".format(self.context))
+        self.flag = None
+        self.flag_got_value = False
+        self.result = ParseResult()
+        self.contexts = copy.deepcopy(contexts)
+        debug("Available contexts: {!r}".format(self.contexts))
+        # In case StateMachine does anything in __init__
+        super().__init__()
+
+    @property
+    def waiting_for_flag_value(self) -> bool:
+        # Do we have a current flag, and does it expect a value (vs being a
+        # bool/toggle)?
+        takes_value = self.flag and self.flag.takes_value
+        if not takes_value:
+            return False
+        # OK, this flag is one that takes values.
+        # Is it a list type (which has only just been switched to)? Then it'll
+        # always accept more values.
+        # TODO: how to handle somebody wanting it to be some other iterable
+        # like tuple or custom class? Or do we just say unsupported?
+        if self.flag.kind is list and not self.flag_got_value:
+            return True
+        # Not a list, okay. Does it already have a value?
+        has_value = self.flag.raw_value is not None
+        # If it doesn't have one, we're waiting for one (which tells the parser
+        # how to proceed and typically to store the next token.)
+        # TODO: in the negative case here, we should do something else instead:
+        # - Except, "hey you screwed up, you already gave that flag!"
+        # - Overwrite, "oh you changed your mind?" - which requires more work
+        # elsewhere too, unfortunately. (Perhaps additional properties on
+        # Argument that can be queried, e.g. "arg.is_iterable"?)
+        return not has_value
+
+    def handle(self, token: str) -> None:
+        debug("Handling token: {!r}".format(token))
+        # Handle unknown state at the top: we don't care about even
+        # possibly-valid input if we've encountered unknown input.
+        if self.current_state == "unknown":
+            debug("Top-of-handle() see_unknown({!r})".format(token))
+            self.see_unknown(token)
+            return
+        # Flag
+        if self.context and token in self.context.flags:
+            debug("Saw flag {!r}".format(token))
+            self.switch_to_flag(token)
+        elif self.context and token in self.context.inverse_flags:
+            debug("Saw inverse flag {!r}".format(token))
+            self.switch_to_flag(token, inverse=True)
+        # Value for current flag
+        elif self.waiting_for_flag_value:
+            debug(
+                "We're waiting for a flag value so {!r} must be it?".format(
+                    token
+                )
+            )  # noqa
+            self.see_value(token)
+        # Positional args (must come above context-name check in case we still
+        # need a posarg and the user legitimately wants to give it a value that
+        # just happens to be a valid context name.)
+        elif self.context and self.context.missing_positional_args:
+            msg = "Context {!r} requires positional args, eating {!r}"
+            debug(msg.format(self.context, token))
+            self.see_positional_arg(token)
+        # New context
+        elif token in self.contexts:
+            self.see_context(token)
+        # Initial-context flag being given as per-task flag (e.g. --help)
+        elif self.initial and token in self.initial.flags:
+            debug("Saw (initial-context) flag {!r}".format(token))
+            flag = self.initial.flags[token]
+            # Special-case for core --help flag: context name is used as value.
+            if flag.name == "help":
+                flag.value = self.context.name
+                msg = "Saw --help in a per-task context, setting task name ({!r}) as its value"  # noqa
+                debug(msg.format(flag.value))
+            # All others: just enter the 'switch to flag' parser state
+            else:
+                # TODO: handle inverse core flags too? There are none at the
+                # moment (e.g. --no-dedupe is actually 'no_dedupe', not a
+                # default-False 'dedupe') and it's up to us whether we actually
+                # put any in place.
+                self.switch_to_flag(token)
+        # Unknown
+        else:
+            if not self.ignore_unknown:
+                debug("Can't find context named {!r}, erroring".format(token))
+                self.error("No idea what {!r} is!".format(token))
+            else:
+                debug("Bottom-of-handle() see_unknown({!r})".format(token))
+                self.see_unknown(token)
+
+    def store_only(self, token: str) -> None:
+        # Start off the unparsed list
+        debug("Storing unknown token {!r}".format(token))
+        self.result.unparsed.append(token)
+
+    def complete_context(self) -> None:
+        debug(
+            "Wrapping up context {!r}".format(
+                self.context.name if self.context else self.context
+            )
+        )
+        # Ensure all of context's positional args have been given.
+        if self.context and self.context.missing_positional_args:
+            err = "'{}' did not receive required positional arguments: {}"
+            names = ", ".join(
+                "'{}'".format(x.name)
+                for x in self.context.missing_positional_args
+            )
+            self.error(err.format(self.context.name, names))
+        if self.context and self.context not in self.result:
+            self.result.append(self.context)
+
+    def switch_to_context(self, name: str) -> None:
+        self.context = copy.deepcopy(self.contexts[name])
+        debug("Moving to context {!r}".format(name))
+        debug("Context args: {!r}".format(self.context.args))
+        debug("Context flags: {!r}".format(self.context.flags))
+        debug("Context inverse_flags: {!r}".format(self.context.inverse_flags))
+
+    def complete_flag(self) -> None:
+        if self.flag:
+            msg = "Completing current flag {} before moving on"
+            debug(msg.format(self.flag))
+        # Barf if we needed a value and didn't get one
+        if (
+            self.flag
+            and self.flag.takes_value
+            and self.flag.raw_value is None
+            and not self.flag.optional
+        ):
+            err = "Flag {!r} needed value and was not given one!"
+            self.error(err.format(self.flag))
+        # Handle optional-value flags; at this point they were not given an
+        # explicit value, but they were seen, ergo they should get treated like
+        # bools.
+        if self.flag and self.flag.raw_value is None and self.flag.optional:
+            msg = "Saw optional flag {!r} go by w/ no value; setting to True"
+            debug(msg.format(self.flag.name))
+            # Skip casting so the bool gets preserved
+            self.flag.set_value(True, cast=False)
+
+    def check_ambiguity(self, value: Any) -> bool:
+        """
+        Guard against ambiguity when current flag takes an optional value.
+
+        .. versionadded:: 1.0
+        """
+        # No flag is currently being examined, or one is but it doesn't take an
+        # optional value? Ambiguity isn't possible.
+        if not (self.flag and self.flag.optional):
+            return False
+        # We *are* dealing with an optional-value flag, but it's already
+        # received a value? There can't be ambiguity here either.
+        if self.flag.raw_value is not None:
+            return False
+        # Otherwise, there *may* be ambiguity if 1 or more of the below tests
+        # fail.
+        tests = []
+        # Unfilled posargs still exist?
+        tests.append(self.context and self.context.missing_positional_args)
+        # Value matches another valid task/context name?
+        tests.append(value in self.contexts)
+        if any(tests):
+            msg = "{!r} is ambiguous when given after an optional-value flag"
+            raise ParseError(msg.format(value))
+
+    def switch_to_flag(self, flag: str, inverse: bool = False) -> None:
+        # Sanity check for ambiguity w/ prior optional-value flag
+        self.check_ambiguity(flag)
+        # Also tie it off, in case prior had optional value or etc. Seems to be
+        # harmless for other kinds of flags. (TODO: this is a serious indicator
+        # that we need to move some of this flag-by-flag bookkeeping into the
+        # state machine bits, if possible - as-is it was REAL confusing re: why
+        # this was manually required!)
+        self.complete_flag()
+        # Set flag/arg obj
+        flag = self.context.inverse_flags[flag] if inverse else flag
+        # Update state
+        try:
+            self.flag = self.context.flags[flag]
+        except KeyError as e:
+            # Try fallback to initial/core flag
+            try:
+                self.flag = self.initial.flags[flag]
+            except KeyError:
+                # If it wasn't in either, raise the original context's
+                # exception, as that's more useful / correct.
+                raise e
+        debug("Moving to flag {!r}".format(self.flag))
+        # Bookkeeping for iterable-type flags (where the typical 'value
+        # non-empty/nondefault -> clearly it got its value already' test is
+        # insufficient)
+        self.flag_got_value = False
+        # Handle boolean flags (which can immediately be updated)
+        if self.flag and not self.flag.takes_value:
+            val = not inverse
+            debug("Marking seen flag {!r} as {}".format(self.flag, val))
+            self.flag.value = val
+
+    def see_value(self, value: Any) -> None:
+        self.check_ambiguity(value)
+        if self.flag and self.flag.takes_value:
+            debug("Setting flag {!r} to value {!r}".format(self.flag, value))
+            self.flag.value = value
+            self.flag_got_value = True
+        else:
+            self.error("Flag {!r} doesn't take any value!".format(self.flag))
+
+    def see_positional_arg(self, value: Any) -> None:
+        for arg in self.context.positional_args:
+            if arg.value is None:
+                arg.value = value
+                break
+
+    def error(self, msg: str) -> None:
+        raise ParseError(msg, self.context)

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/fluidity/__init__.py

@@ -0,0 +1,4 @@
+from .machine import (StateMachine, state, transition,
+                               InvalidConfiguration, InvalidTransition,
+                               GuardNotSatisfied, ForkedTransition)
+

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/fluidity/backwardscompat.py

@@ -0,0 +1,8 @@
+import sys
+
+if sys.version_info >= (3,):
+    def callable(obj):
+        return hasattr(obj, '__call__')
+else:
+    callable = callable
+

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/fluidity/machine.py

@@ -0,0 +1,270 @@
+import re
+import inspect
+from .backwardscompat import callable
+
+# metaclass implementation idea from
+# http://blog.ianbicking.org/more-on-python-metaprogramming-comment-14.html
+_transition_gatherer = []
+
+def transition(event, from_, to, action=None, guard=None):
+    _transition_gatherer.append([event, from_, to, action, guard])
+
+_state_gatherer = []
+
+def state(name, enter=None, exit=None):
+    _state_gatherer.append([name, enter, exit])
+
+
+class MetaStateMachine(type):
+
+    def __new__(cls, name, bases, dictionary):
+        global _transition_gatherer, _state_gatherer
+        Machine = super(MetaStateMachine, cls).__new__(cls, name, bases, dictionary)
+        Machine._class_transitions = []
+        Machine._class_states = {}
+        for s in _state_gatherer:
+            Machine._add_class_state(*s)
+        for i in _transition_gatherer:
+            Machine._add_class_transition(*i)
+        _transition_gatherer = []
+        _state_gatherer = []
+        return Machine
+
+
+StateMachineBase = MetaStateMachine('StateMachineBase', (object, ), {})
+
+
+class StateMachine(StateMachineBase):
+
+    def __init__(self):
+        self._bring_definitions_to_object_level()
+        self._inject_into_parts()
+        self._validate_machine_definitions()
+        if callable(self.initial_state):
+            self.initial_state = self.initial_state()
+        self._current_state_object = self._state_by_name(self.initial_state)
+        self._current_state_object.run_enter(self)
+        self._create_state_getters()
+
+    def __new__(cls, *args, **kwargs):
+        obj = super(StateMachine, cls).__new__(cls)
+        obj._states = {}
+        obj._transitions = []
+        return obj
+
+    def _bring_definitions_to_object_level(self):
+        self._states.update(self.__class__._class_states)
+        self._transitions.extend(self.__class__._class_transitions)
+
+    def _inject_into_parts(self):
+        for collection in [self._states.values(), self._transitions]:
+            for component in collection:
+                component.machine = self
+
+    def _validate_machine_definitions(self):
+        if len(self._states) < 2:
+            raise InvalidConfiguration('There must be at least two states')
+        if not getattr(self, 'initial_state', None):
+            raise InvalidConfiguration('There must exist an initial state')
+
+    @classmethod
+    def _add_class_state(cls, name, enter, exit):
+        cls._class_states[name] = _State(name, enter, exit)
+
+    def add_state(self, name, enter=None, exit=None):
+        state = _State(name, enter, exit)
+        setattr(self, state.getter_name(), state.getter_method().__get__(self, self.__class__))
+        self._states[name] = state
+
+    def _current_state_name(self):
+        return self._current_state_object.name
+
+    current_state = property(_current_state_name)
+
+    def changing_state(self, from_, to):
+        """
+        This method is called whenever a state change is executed
+        """
+        pass
+
+    def _new_state(self, state):
+        self.changing_state(self._current_state_object.name, state.name)
+        self._current_state_object = state
+
+    def _state_objects(self):
+        return list(self._states.values())
+
+    def states(self):
+        return [s.name for s in self._state_objects()]
+
+    @classmethod
+    def _add_class_transition(cls, event, from_, to, action, guard):
+        transition = _Transition(event, [cls._class_states[s] for s in _listize(from_)],
+            cls._class_states[to], action, guard)
+        cls._class_transitions.append(transition)
+        setattr(cls, event, transition.event_method())
+
+    def add_transition(self, event, from_, to, action=None, guard=None):
+        transition = _Transition(event, [self._state_by_name(s) for s in _listize(from_)],
+            self._state_by_name(to), action, guard)
+        self._transitions.append(transition)
+        setattr(self, event, transition.event_method().__get__(self, self.__class__))
+
+    def _process_transitions(self, event_name, *args, **kwargs):
+        transitions = self._transitions_by_name(event_name)
+        transitions = self._ensure_from_validity(transitions)
+        this_transition = self._check_guards(transitions)
+        this_transition.run(self, *args, **kwargs)
+
+    def _create_state_getters(self):
+        for state in self._state_objects():
+            setattr(self, state.getter_name(), state.getter_method().__get__(self, self.__class__))
+
+    def _state_by_name(self, name):
+        for state in self._state_objects():
+            if state.name == name:
+                return state
+
+    def _transitions_by_name(self, name):
+        return list(filter(lambda transition: transition.event == name, self._transitions))
+
+    def _ensure_from_validity(self, transitions):
+        valid_transitions = list(filter(
+          lambda transition: transition.is_valid_from(self._current_state_object),
+          transitions))
+        if len(valid_transitions) == 0:
+            raise InvalidTransition("Cannot %s from %s" % (
+                transitions[0].event, self.current_state))
+        return valid_transitions
+
+    def _check_guards(self, transitions):
+        allowed_transitions = []
+        for transition in transitions:
+            if transition.check_guard(self):
+                allowed_transitions.append(transition)
+        if len(allowed_transitions) == 0:
+            raise GuardNotSatisfied("Guard is not satisfied for this transition")
+        elif len(allowed_transitions) > 1:
+            raise ForkedTransition("More than one transition was allowed for this event")
+        return allowed_transitions[0]
+
+
+class _Transition(object):
+
+    def __init__(self, event, from_, to, action, guard):
+        self.event = event
+        self.from_ = from_
+        self.to = to
+        self.action = action
+        self.guard = _Guard(guard)
+
+    def event_method(self):
+        def generated_event(machine, *args, **kwargs):
+            these_transitions = machine._process_transitions(self.event, *args, **kwargs)
+        generated_event.__doc__ = 'event %s' % self.event
+        generated_event.__name__ = self.event
+        return generated_event
+
+    def is_valid_from(self, from_):
+        return from_ in _listize(self.from_)
+
+    def check_guard(self, machine):
+        return self.guard.check(machine)
+
+    def run(self, machine, *args, **kwargs):
+        machine._current_state_object.run_exit(machine)
+        machine._new_state(self.to)
+        self.to.run_enter(machine)
+        _ActionRunner(machine).run(self.action, *args, **kwargs)
+
+
+class _Guard(object):
+
+    def __init__(self, action):
+        self.action = action
+
+    def check(self, machine):
+        if self.action is None:
+            return True
+        items = _listize(self.action)
+        result = True
+        for item in items:
+            result = result and self._evaluate(machine, item)
+        return result
+
+    def _evaluate(self, machine, item):
+        if callable(item):
+            return item(machine)
+        else:
+            guard = getattr(machine, item)
+            if callable(guard):
+                guard = guard()
+            return guard
+
+
+class _State(object):
+
+    def __init__(self, name, enter, exit):
+        self.name = name
+        self.enter = enter
+        self.exit = exit
+
+    def getter_name(self):
+        return 'is_%s' % self.name
+
+    def getter_method(self):
+        def state_getter(self_machine):
+            return self_machine.current_state == self.name
+        return state_getter
+
+    def run_enter(self, machine):
+        _ActionRunner(machine).run(self.enter)
+
+    def run_exit(self, machine):
+        _ActionRunner(machine).run(self.exit)
+
+
+class _ActionRunner(object):
+
+    def __init__(self, machine):
+        self.machine = machine
+
+    def run(self, action_param, *args, **kwargs):
+        if not action_param:
+            return
+        action_items = _listize(action_param)
+        for action_item in action_items:
+            self._run_action(action_item, *args, **kwargs)
+
+    def _run_action(self, action, *args, **kwargs):
+        if callable(action):
+            self._try_to_run_with_args(action, self.machine, *args, **kwargs)
+        else:
+            self._try_to_run_with_args(getattr(self.machine, action), *args, **kwargs)
+
+    def _try_to_run_with_args(self, action, *args, **kwargs):
+        try:
+            action(*args, **kwargs)
+        except TypeError:
+            action()
+
+
+class InvalidConfiguration(Exception):
+    pass
+
+
+class InvalidTransition(Exception):
+    pass
+
+
+class GuardNotSatisfied(Exception):
+    pass
+
+
+class ForkedTransition(Exception):
+    pass
+
+
+def _listize(value):
+    return type(value) in [list, tuple] and value or [value]
+

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/lexicon/__init__.py

@@ -0,0 +1,24 @@
+from ._version import __version_info__, __version__  # noqa
+from .attribute_dict import AttributeDict
+from .alias_dict import AliasDict
+
+
+class Lexicon(AttributeDict, AliasDict):
+    def __init__(self, *args, **kwargs):
+        # Need to avoid combining AliasDict's initial attribute write on
+        # self.aliases, with AttributeDict's __setattr__. Doing so results in
+        # an infinite loop. Instead, just skip straight to dict() for both
+        # explicitly (i.e. we override AliasDict.__init__ instead of extending
+        # it.)
+        # NOTE: could tickle AttributeDict.__init__ instead, in case it ever
+        # grows one.
+        dict.__init__(self, *args, **kwargs)
+        dict.__setattr__(self, "aliases", {})
+
+    def __getattr__(self, key):
+        # Intercept deepcopy/etc driven access to self.aliases when not
+        # actually set. (Only a problem for us, due to abovementioned combo of
+        # Alias and Attribute Dicts, so not solvable in a parent alone.)
+        if key == "aliases" and key not in self.__dict__:
+            self.__dict__[key] = {}
+        return super(Lexicon, self).__getattr__(key)

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/lexicon/_version.py

@@ -0,0 +1,2 @@
+__version_info__ = (2, 0, 1)
+__version__ = ".".join(map(str, __version_info__))

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/lexicon/alias_dict.py

@@ -0,0 +1,95 @@
+class AliasDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AliasDict, self).__init__(*args, **kwargs)
+        self.aliases = {}
+
+    def alias(self, from_, to):
+        self.aliases[from_] = to
+
+    def unalias(self, from_):
+        del self.aliases[from_]
+
+    def aliases_of(self, name):
+        """
+        Returns other names for given real key or alias ``name``.
+
+        If given a real key, returns its aliases.
+
+        If given an alias, returns the real key it points to, plus any other
+        aliases of that real key. (The given alias itself is not included in
+        the return value.)
+        """
+        names = []
+        key = name
+        # self.aliases keys are aliases, not realkeys. Easy test to see if we
+        # should flip around to the POV of a realkey when given an alias.
+        if name in self.aliases:
+            key = self.aliases[name]
+            # Ensure the real key shows up in output.
+            names.append(key)
+        # 'key' is now a realkey, whose aliases are all keys whose value is
+        # itself. Filter out the original name given.
+        names.extend(
+            [k for k, v in self.aliases.items() if v == key and k != name]
+        )
+        return names
+
+    def _handle(self, key, value, single, multi, unaliased):
+        # Attribute existence test required to not blow up when deepcopy'd
+        if key in getattr(self, "aliases", {}):
+            target = self.aliases[key]
+            # Single-string targets
+            if isinstance(target, str):
+                return single(self, target, value)
+            # Multi-string targets
+            else:
+                if multi:
+                    return multi(self, target, value)
+                else:
+                    for subkey in target:
+                        single(self, subkey, value)
+        else:
+            return unaliased(self, key, value)
+
+    def __setitem__(self, key, value):
+        def single(d, target, value):
+            d[target] = value
+
+        def unaliased(d, key, value):
+            super(AliasDict, d).__setitem__(key, value)
+
+        return self._handle(key, value, single, None, unaliased)
+
+    def __getitem__(self, key):
+        def single(d, target, value):
+            return d[target]
+
+        def unaliased(d, key, value):
+            return super(AliasDict, d).__getitem__(key)
+
+        def multi(d, target, value):
+            msg = "Multi-target aliases have no well-defined value and can't be read."  # noqa
+            raise ValueError(msg)
+
+        return self._handle(key, None, single, multi, unaliased)
+
+    def __contains__(self, key):
+        def single(d, target, value):
+            return target in d
+
+        def multi(d, target, value):
+            return all(subkey in self for subkey in self.aliases[key])
+
+        def unaliased(d, key, value):
+            return super(AliasDict, d).__contains__(key)
+
+        return self._handle(key, None, single, multi, unaliased)
+
+    def __delitem__(self, key):
+        def single(d, target, value):
+            del d[target]
+
+        def unaliased(d, key, value):
+            return super(AliasDict, d).__delitem__(key)
+
+        return self._handle(key, None, single, None, unaliased)

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/lexicon/attribute_dict.py

@@ -0,0 +1,16 @@
+class AttributeDict(dict):
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            # to conform with __getattr__ spec
+            raise AttributeError(key)
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __delattr__(self, key):
+        del self[key]
+
+    def __dir__(self):
+        return dir(type(self)) + list(self.keys())

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/yaml/__init__.py

@@ -0,0 +1,427 @@
+
+from .error import *
+
+from .tokens import *
+from .events import *
+from .nodes import *
+
+from .loader import *
+from .dumper import *
+
+__version__ = '5.4.1'
+try:
+    from .cyaml import *
+    __with_libyaml__ = True
+except ImportError:
+    __with_libyaml__ = False
+
+import io
+
+#------------------------------------------------------------------------------
+# Warnings control
+#------------------------------------------------------------------------------
+
+# 'Global' warnings state:
+_warnings_enabled = {
+    'YAMLLoadWarning': True,
+}
+
+# Get or set global warnings' state
+def warnings(settings=None):
+    if settings is None:
+        return _warnings_enabled
+
+    if type(settings) is dict:
+        for key in settings:
+            if key in _warnings_enabled:
+                _warnings_enabled[key] = settings[key]
+
+# Warn when load() is called without Loader=...
+class YAMLLoadWarning(RuntimeWarning):
+    pass
+
+def load_warning(method):
+    if _warnings_enabled['YAMLLoadWarning'] is False:
+        return
+
+    import warnings
+
+    message = (
+        "calling yaml.%s() without Loader=... is deprecated, as the "
+        "default Loader is unsafe. Please read "
+        "https://msg.pyyaml.org/load for full details."
+    ) % method
+
+    warnings.warn(message, YAMLLoadWarning, stacklevel=3)
+
+#------------------------------------------------------------------------------
+def scan(stream, Loader=Loader):
+    """
+    Scan a YAML stream and produce scanning tokens.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_token():
+            yield loader.get_token()
+    finally:
+        loader.dispose()
+
+def parse(stream, Loader=Loader):
+    """
+    Parse a YAML stream and produce parsing events.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_event():
+            yield loader.get_event()
+    finally:
+        loader.dispose()
+
+def compose(stream, Loader=Loader):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding representation tree.
+    """
+    loader = Loader(stream)
+    try:
+        return loader.get_single_node()
+    finally:
+        loader.dispose()
+
+def compose_all(stream, Loader=Loader):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding representation trees.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_node():
+            yield loader.get_node()
+    finally:
+        loader.dispose()
+
+def load(stream, Loader=None):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+    """
+    if Loader is None:
+        load_warning('load')
+        Loader = FullLoader
+
+    loader = Loader(stream)
+    try:
+        return loader.get_single_data()
+    finally:
+        loader.dispose()
+
+def load_all(stream, Loader=None):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+    """
+    if Loader is None:
+        load_warning('load_all')
+        Loader = FullLoader
+
+    loader = Loader(stream)
+    try:
+        while loader.check_data():
+            yield loader.get_data()
+    finally:
+        loader.dispose()
+
+def full_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+
+    Resolve all tags except those known to be
+    unsafe on untrusted input.
+    """
+    return load(stream, FullLoader)
+
+def full_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+
+    Resolve all tags except those known to be
+    unsafe on untrusted input.
+    """
+    return load_all(stream, FullLoader)
+
+def safe_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+
+    Resolve only basic YAML tags. This is known
+    to be safe for untrusted input.
+    """
+    return load(stream, SafeLoader)
+
+def safe_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+
+    Resolve only basic YAML tags. This is known
+    to be safe for untrusted input.
+    """
+    return load_all(stream, SafeLoader)
+
+def unsafe_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+
+    Resolve all tags, even those known to be
+    unsafe on untrusted input.
+    """
+    return load(stream, UnsafeLoader)
+
+def unsafe_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+
+    Resolve all tags, even those known to be
+    unsafe on untrusted input.
+    """
+    return load_all(stream, UnsafeLoader)
+
+def emit(events, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None):
+    """
+    Emit YAML parsing events into a stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        stream = io.StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break)
+    try:
+        for event in events:
+            dumper.emit(event)
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def serialize_all(nodes, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding=None, explicit_start=None, explicit_end=None,
+        version=None, tags=None):
+    """
+    Serialize a sequence of representation trees into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            stream = io.StringIO()
+        else:
+            stream = io.BytesIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end)
+    try:
+        dumper.open()
+        for node in nodes:
+            dumper.serialize(node)
+        dumper.close()
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def serialize(node, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a representation tree into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return serialize_all([node], stream, Dumper=Dumper, **kwds)
+
+def dump_all(documents, stream=None, Dumper=Dumper,
+        default_style=None, default_flow_style=False,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding=None, explicit_start=None, explicit_end=None,
+        version=None, tags=None, sort_keys=True):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            stream = io.StringIO()
+        else:
+            stream = io.BytesIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, default_style=default_style,
+            default_flow_style=default_flow_style,
+            canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end, sort_keys=sort_keys)
+    try:
+        dumper.open()
+        for data in documents:
+            dumper.represent(data)
+        dumper.close()
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def dump(data, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=Dumper, **kwds)
+
+def safe_dump_all(documents, stream=None, **kwds):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all(documents, stream, Dumper=SafeDumper, **kwds)
+
+def safe_dump(data, stream=None, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=SafeDumper, **kwds)
+
+def add_implicit_resolver(tag, regexp, first=None,
+        Loader=None, Dumper=Dumper):
+    """
+    Add an implicit scalar detector.
+    If an implicit scalar value matches the given regexp,
+    the corresponding tag is assigned to the scalar.
+    first is a sequence of possible initial characters or None.
+    """
+    if Loader is None:
+        loader.Loader.add_implicit_resolver(tag, regexp, first)
+        loader.FullLoader.add_implicit_resolver(tag, regexp, first)
+        loader.UnsafeLoader.add_implicit_resolver(tag, regexp, first)
+    else:
+        Loader.add_implicit_resolver(tag, regexp, first)
+    Dumper.add_implicit_resolver(tag, regexp, first)
+
+def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=Dumper):
+    """
+    Add a path based resolver for the given tag.
+    A path is a list of keys that forms a path
+    to a node in the representation tree.
+    Keys can be string values, integers, or None.
+    """
+    if Loader is None:
+        loader.Loader.add_path_resolver(tag, path, kind)
+        loader.FullLoader.add_path_resolver(tag, path, kind)
+        loader.UnsafeLoader.add_path_resolver(tag, path, kind)
+    else:
+        Loader.add_path_resolver(tag, path, kind)
+    Dumper.add_path_resolver(tag, path, kind)
+
+def add_constructor(tag, constructor, Loader=None):
+    """
+    Add a constructor for the given tag.
+    Constructor is a function that accepts a Loader instance
+    and a node object and produces the corresponding Python object.
+    """
+    if Loader is None:
+        loader.Loader.add_constructor(tag, constructor)
+        loader.FullLoader.add_constructor(tag, constructor)
+        loader.UnsafeLoader.add_constructor(tag, constructor)
+    else:
+        Loader.add_constructor(tag, constructor)
+
+def add_multi_constructor(tag_prefix, multi_constructor, Loader=None):
+    """
+    Add a multi-constructor for the given tag prefix.
+    Multi-constructor is called for a node if its tag starts with tag_prefix.
+    Multi-constructor accepts a Loader instance, a tag suffix,
+    and a node object and produces the corresponding Python object.
+    """
+    if Loader is None:
+        loader.Loader.add_multi_constructor(tag_prefix, multi_constructor)
+        loader.FullLoader.add_multi_constructor(tag_prefix, multi_constructor)
+        loader.UnsafeLoader.add_multi_constructor(tag_prefix, multi_constructor)
+    else:
+        Loader.add_multi_constructor(tag_prefix, multi_constructor)
+
+def add_representer(data_type, representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Representer is a function accepting a Dumper instance
+    and an instance of the given data type
+    and producing the corresponding representation node.
+    """
+    Dumper.add_representer(data_type, representer)
+
+def add_multi_representer(data_type, multi_representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Multi-representer is a function accepting a Dumper instance
+    and an instance of the given data type or subtype
+    and producing the corresponding representation node.
+    """
+    Dumper.add_multi_representer(data_type, multi_representer)
+
+class YAMLObjectMetaclass(type):
+    """
+    The metaclass for YAMLObject.
+    """
+    def __init__(cls, name, bases, kwds):
+        super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
+        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
+            if isinstance(cls.yaml_loader, list):
+                for loader in cls.yaml_loader:
+                    loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+            else:
+                cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+
+            cls.yaml_dumper.add_representer(cls, cls.to_yaml)
+
+class YAMLObject(metaclass=YAMLObjectMetaclass):
+    """
+    An object that can dump itself to a YAML stream
+    and load itself from a YAML stream.
+    """
+
+    __slots__ = ()  # no direct instantiation, so allow immutable subclasses
+
+    yaml_loader = [Loader, FullLoader, UnsafeLoader]
+    yaml_dumper = Dumper
+
+    yaml_tag = None
+    yaml_flow_style = None
+
+    @classmethod
+    def from_yaml(cls, loader, node):
+        """
+        Convert a representation node to a Python object.
+        """
+        return loader.construct_yaml_object(node, cls)
+
+    @classmethod
+    def to_yaml(cls, dumper, data):
+        """
+        Convert a Python object to a representation node.
+        """
+        return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
+                flow_style=cls.yaml_flow_style)
+

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/yaml/composer.py

@@ -0,0 +1,139 @@
+
+__all__ = ['Composer', 'ComposerError']
+
+from .error import MarkedYAMLError
+from .events import *
+from .nodes import *
+
+class ComposerError(MarkedYAMLError):
+    pass
+
+class Composer:
+
+    def __init__(self):
+        self.anchors = {}
+
+    def check_node(self):
+        # Drop the STREAM-START event.
+        if self.check_event(StreamStartEvent):
+            self.get_event()
+
+        # If there are more documents available?
+        return not self.check_event(StreamEndEvent)
+
+    def get_node(self):
+        # Get the root node of the next document.
+        if not self.check_event(StreamEndEvent):
+            return self.compose_document()
+
+    def get_single_node(self):
+        # Drop the STREAM-START event.
+        self.get_event()
+
+        # Compose a document if the stream is not empty.
+        document = None
+        if not self.check_event(StreamEndEvent):
+            document = self.compose_document()
+
+        # Ensure that the stream contains no more documents.
+        if not self.check_event(StreamEndEvent):
+            event = self.get_event()
+            raise ComposerError("expected a single document in the stream",
+                    document.start_mark, "but found another document",
+                    event.start_mark)
+
+        # Drop the STREAM-END event.
+        self.get_event()
+
+        return document
+
+    def compose_document(self):
+        # Drop the DOCUMENT-START event.
+        self.get_event()
+
+        # Compose the root node.
+        node = self.compose_node(None, None)
+
+        # Drop the DOCUMENT-END event.
+        self.get_event()
+
+        self.anchors = {}
+        return node
+
+    def compose_node(self, parent, index):
+        if self.check_event(AliasEvent):
+            event = self.get_event()
+            anchor = event.anchor
+            if anchor not in self.anchors:
+                raise ComposerError(None, None, "found undefined alias %r"
+                        % anchor, event.start_mark)
+            return self.anchors[anchor]
+        event = self.peek_event()
+        anchor = event.anchor
+        if anchor is not None:
+            if anchor in self.anchors:
+                raise ComposerError("found duplicate anchor %r; first occurrence"
+                        % anchor, self.anchors[anchor].start_mark,
+                        "second occurrence", event.start_mark)
+        self.descend_resolver(parent, index)
+        if self.check_event(ScalarEvent):
+            node = self.compose_scalar_node(anchor)
+        elif self.check_event(SequenceStartEvent):
+            node = self.compose_sequence_node(anchor)
+        elif self.check_event(MappingStartEvent):
+            node = self.compose_mapping_node(anchor)
+        self.ascend_resolver()
+        return node
+
+    def compose_scalar_node(self, anchor):
+        event = self.get_event()
+        tag = event.tag
+        if tag is None or tag == '!':
+            tag = self.resolve(ScalarNode, event.value, event.implicit)
+        node = ScalarNode(tag, event.value,
+                event.start_mark, event.end_mark, style=event.style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        return node
+
+    def compose_sequence_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == '!':
+            tag = self.resolve(SequenceNode, None, start_event.implicit)
+        node = SequenceNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        index = 0
+        while not self.check_event(SequenceEndEvent):
+            node.value.append(self.compose_node(node, index))
+            index += 1
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+
+    def compose_mapping_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == '!':
+            tag = self.resolve(MappingNode, None, start_event.implicit)
+        node = MappingNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        while not self.check_event(MappingEndEvent):
+            #key_event = self.peek_event()
+            item_key = self.compose_node(node, None)
+            #if item_key in node.value:
+            #    raise ComposerError("while composing a mapping", start_event.start_mark,
+            #            "found duplicate key", key_event.start_mark)
+            item_value = self.compose_node(node, item_key)
+            #node.value[item_key] = item_value
+            node.value.append((item_key, item_value))
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/yaml/constructor.py

@@ -0,0 +1,748 @@
+
+__all__ = [
+    'BaseConstructor',
+    'SafeConstructor',
+    'FullConstructor',
+    'UnsafeConstructor',
+    'Constructor',
+    'ConstructorError'
+]
+
+from .error import *
+from .nodes import *
+
+import collections.abc, datetime, base64, binascii, re, sys, types
+
+class ConstructorError(MarkedYAMLError):
+    pass
+
+class BaseConstructor:
+
+    yaml_constructors = {}
+    yaml_multi_constructors = {}
+
+    def __init__(self):
+        self.constructed_objects = {}
+        self.recursive_objects = {}
+        self.state_generators = []
+        self.deep_construct = False
+
+    def check_data(self):
+        # If there are more documents available?
+        return self.check_node()
+
+    def check_state_key(self, key):
+        """Block special attributes/methods from being set in a newly created
+        object, to prevent user-controlled methods from being called during
+        deserialization"""
+        if self.get_state_keys_blacklist_regexp().match(key):
+            raise ConstructorError(None, None,
+                "blacklisted key '%s' in instance state found" % (key,), None)
+
+    def get_data(self):
+        # Construct and return the next document.
+        if self.check_node():
+            return self.construct_document(self.get_node())
+
+    def get_single_data(self):
+        # Ensure that the stream contains a single document and construct it.
+        node = self.get_single_node()
+        if node is not None:
+            return self.construct_document(node)
+        return None
+
+    def construct_document(self, node):
+        data = self.construct_object(node)
+        while self.state_generators:
+            state_generators = self.state_generators
+            self.state_generators = []
+            for generator in state_generators:
+                for dummy in generator:
+                    pass
+        self.constructed_objects = {}
+        self.recursive_objects = {}
+        self.deep_construct = False
+        return data
+
+    def construct_object(self, node, deep=False):
+        if node in self.constructed_objects:
+            return self.constructed_objects[node]
+        if deep:
+            old_deep = self.deep_construct
+            self.deep_construct = True
+        if node in self.recursive_objects:
+            raise ConstructorError(None, None,
+                    "found unconstructable recursive node", node.start_mark)
+        self.recursive_objects[node] = None
+        constructor = None
+        tag_suffix = None
+        if node.tag in self.yaml_constructors:
+            constructor = self.yaml_constructors[node.tag]
+        else:
+            for tag_prefix in self.yaml_multi_constructors:
+                if tag_prefix is not None and node.tag.startswith(tag_prefix):
+                    tag_suffix = node.tag[len(tag_prefix):]
+                    constructor = self.yaml_multi_constructors[tag_prefix]
+                    break
+            else:
+                if None in self.yaml_multi_constructors:
+                    tag_suffix = node.tag
+                    constructor = self.yaml_multi_constructors[None]
+                elif None in self.yaml_constructors:
+                    constructor = self.yaml_constructors[None]
+                elif isinstance(node, ScalarNode):
+                    constructor = self.__class__.construct_scalar
+                elif isinstance(node, SequenceNode):
+                    constructor = self.__class__.construct_sequence
+                elif isinstance(node, MappingNode):
+                    constructor = self.__class__.construct_mapping
+        if tag_suffix is None:
+            data = constructor(self, node)
+        else:
+            data = constructor(self, tag_suffix, node)
+        if isinstance(data, types.GeneratorType):
+            generator = data
+            data = next(generator)
+            if self.deep_construct:
+                for dummy in generator:
+                    pass
+            else:
+                self.state_generators.append(generator)
+        self.constructed_objects[node] = data
+        del self.recursive_objects[node]
+        if deep:
+            self.deep_construct = old_deep
+        return data
+
+    def construct_scalar(self, node):
+        if not isinstance(node, ScalarNode):
+            raise ConstructorError(None, None,
+                    "expected a scalar node, but found %s" % node.id,
+                    node.start_mark)
+        return node.value
+
+    def construct_sequence(self, node, deep=False):
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError(None, None,
+                    "expected a sequence node, but found %s" % node.id,
+                    node.start_mark)
+        return [self.construct_object(child, deep=deep)
+                for child in node.value]
+
+    def construct_mapping(self, node, deep=False):
+        if not isinstance(node, MappingNode):
+            raise ConstructorError(None, None,
+                    "expected a mapping node, but found %s" % node.id,
+                    node.start_mark)
+        mapping = {}
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            if not isinstance(key, collections.abc.Hashable):
+                raise ConstructorError("while constructing a mapping", node.start_mark,
+                        "found unhashable key", key_node.start_mark)
+            value = self.construct_object(value_node, deep=deep)
+            mapping[key] = value
+        return mapping
+
+    def construct_pairs(self, node, deep=False):
+        if not isinstance(node, MappingNode):
+            raise ConstructorError(None, None,
+                    "expected a mapping node, but found %s" % node.id,
+                    node.start_mark)
+        pairs = []
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            value = self.construct_object(value_node, deep=deep)
+            pairs.append((key, value))
+        return pairs
+
+    @classmethod
+    def add_constructor(cls, tag, constructor):
+        if not 'yaml_constructors' in cls.__dict__:
+            cls.yaml_constructors = cls.yaml_constructors.copy()
+        cls.yaml_constructors[tag] = constructor
+
+    @classmethod
+    def add_multi_constructor(cls, tag_prefix, multi_constructor):
+        if not 'yaml_multi_constructors' in cls.__dict__:
+            cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
+        cls.yaml_multi_constructors[tag_prefix] = multi_constructor
+
+class SafeConstructor(BaseConstructor):
+
+    def construct_scalar(self, node):
+        if isinstance(node, MappingNode):
+            for key_node, value_node in node.value:
+                if key_node.tag == 'tag:yaml.org,2002:value':
+                    return self.construct_scalar(value_node)
+        return super().construct_scalar(node)
+
+    def flatten_mapping(self, node):
+        merge = []
+        index = 0
+        while index < len(node.value):
+            key_node, value_node = node.value[index]
+            if key_node.tag == 'tag:yaml.org,2002:merge':
+                del node.value[index]
+                if isinstance(value_node, MappingNode):
+                    self.flatten_mapping(value_node)
+                    merge.extend(value_node.value)
+                elif isinstance(value_node, SequenceNode):
+                    submerge = []
+                    for subnode in value_node.value:
+                        if not isinstance(subnode, MappingNode):
+                            raise ConstructorError("while constructing a mapping",
+                                    node.start_mark,
+                                    "expected a mapping for merging, but found %s"
+                                    % subnode.id, subnode.start_mark)
+                        self.flatten_mapping(subnode)
+                        submerge.append(subnode.value)
+                    submerge.reverse()
+                    for value in submerge:
+                        merge.extend(value)
+                else:
+                    raise ConstructorError("while constructing a mapping", node.start_mark,
+                            "expected a mapping or list of mappings for merging, but found %s"
+                            % value_node.id, value_node.start_mark)
+            elif key_node.tag == 'tag:yaml.org,2002:value':
+                key_node.tag = 'tag:yaml.org,2002:str'
+                index += 1
+            else:
+                index += 1
+        if merge:
+            node.value = merge + node.value
+
+    def construct_mapping(self, node, deep=False):
+        if isinstance(node, MappingNode):
+            self.flatten_mapping(node)
+        return super().construct_mapping(node, deep=deep)
+
+    def construct_yaml_null(self, node):
+        self.construct_scalar(node)
+        return None
+
+    bool_values = {
+        'yes':      True,
+        'no':       False,
+        'true':     True,
+        'false':    False,
+        'on':       True,
+        'off':      False,
+    }
+
+    def construct_yaml_bool(self, node):
+        value = self.construct_scalar(node)
+        return self.bool_values[value.lower()]
+
+    def construct_yaml_int(self, node):
+        value = self.construct_scalar(node)
+        value = value.replace('_', '')
+        sign = +1
+        if value[0] == '-':
+            sign = -1
+        if value[0] in '+-':
+            value = value[1:]
+        if value == '0':
+            return 0
+        elif value.startswith('0b'):
+            return sign*int(value[2:], 2)
+        elif value.startswith('0x'):
+            return sign*int(value[2:], 16)
+        elif value[0] == '0':
+            return sign*int(value, 8)
+        elif ':' in value:
+            digits = [int(part) for part in value.split(':')]
+            digits.reverse()
+            base = 1
+            value = 0
+            for digit in digits:
+                value += digit*base
+                base *= 60
+            return sign*value
+        else:
+            return sign*int(value)
+
+    inf_value = 1e300
+    while inf_value != inf_value*inf_value:
+        inf_value *= inf_value
+    nan_value = -inf_value/inf_value   # Trying to make a quiet NaN (like C99).
+
+    def construct_yaml_float(self, node):
+        value = self.construct_scalar(node)
+        value = value.replace('_', '').lower()
+        sign = +1
+        if value[0] == '-':
+            sign = -1
+        if value[0] in '+-':
+            value = value[1:]
+        if value == '.inf':
+            return sign*self.inf_value
+        elif value == '.nan':
+            return self.nan_value
+        elif ':' in value:
+            digits = [float(part) for part in value.split(':')]
+            digits.reverse()
+            base = 1
+            value = 0.0
+            for digit in digits:
+                value += digit*base
+                base *= 60
+            return sign*value
+        else:
+            return sign*float(value)
+
+    def construct_yaml_binary(self, node):
+        try:
+            value = self.construct_scalar(node).encode('ascii')
+        except UnicodeEncodeError as exc:
+            raise ConstructorError(None, None,
+                    "failed to convert base64 data into ascii: %s" % exc,
+                    node.start_mark)
+        try:
+            if hasattr(base64, 'decodebytes'):
+                return base64.decodebytes(value)
+            else:
+                return base64.decodestring(value)
+        except binascii.Error as exc:
+            raise ConstructorError(None, None,
+                    "failed to decode base64 data: %s" % exc, node.start_mark)
+
+    timestamp_regexp = re.compile(
+            r'''^(?P<year>[0-9][0-9][0-9][0-9])
+                -(?P<month>[0-9][0-9]?)
+                -(?P<day>[0-9][0-9]?)
+                (?:(?:[Tt]|[ \t]+)
+                (?P<hour>[0-9][0-9]?)
+                :(?P<minute>[0-9][0-9])
+                :(?P<second>[0-9][0-9])
+                (?:\.(?P<fraction>[0-9]*))?
+                (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+                (?::(?P<tz_minute>[0-9][0-9]))?))?)?$''', re.X)
+
+    def construct_yaml_timestamp(self, node):
+        value = self.construct_scalar(node)
+        match = self.timestamp_regexp.match(node.value)
+        values = match.groupdict()
+        year = int(values['year'])
+        month = int(values['month'])
+        day = int(values['day'])
+        if not values['hour']:
+            return datetime.date(year, month, day)
+        hour = int(values['hour'])
+        minute = int(values['minute'])
+        second = int(values['second'])
+        fraction = 0
+        tzinfo = None
+        if values['fraction']:
+            fraction = values['fraction'][:6]
+            while len(fraction) < 6:
+                fraction += '0'
+            fraction = int(fraction)
+        if values['tz_sign']:
+            tz_hour = int(values['tz_hour'])
+            tz_minute = int(values['tz_minute'] or 0)
+            delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute)
+            if values['tz_sign'] == '-':
+                delta = -delta
+            tzinfo = datetime.timezone(delta)
+        elif values['tz']:
+            tzinfo = datetime.timezone.utc
+        return datetime.datetime(year, month, day, hour, minute, second, fraction,
+                                 tzinfo=tzinfo)
+
+    def construct_yaml_omap(self, node):
+        # Note: we do not check for duplicate keys, because it's too
+        # CPU-expensive.
+        omap = []
+        yield omap
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError("while constructing an ordered map", node.start_mark,
+                    "expected a sequence, but found %s" % node.id, node.start_mark)
+        for subnode in node.value:
+            if not isinstance(subnode, MappingNode):
+                raise ConstructorError("while constructing an ordered map", node.start_mark,
+                        "expected a mapping of length 1, but found %s" % subnode.id,
+                        subnode.start_mark)
+            if len(subnode.value) != 1:
+                raise ConstructorError("while constructing an ordered map", node.start_mark,
+                        "expected a single mapping item, but found %d items" % len(subnode.value),
+                        subnode.start_mark)
+            key_node, value_node = subnode.value[0]
+            key = self.construct_object(key_node)
+            value = self.construct_object(value_node)
+            omap.append((key, value))
+
+    def construct_yaml_pairs(self, node):
+        # Note: the same code as `construct_yaml_omap`.
+        pairs = []
+        yield pairs
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError("while constructing pairs", node.start_mark,
+                    "expected a sequence, but found %s" % node.id, node.start_mark)
+        for subnode in node.value:
+            if not isinstance(subnode, MappingNode):
+                raise ConstructorError("while constructing pairs", node.start_mark,
+                        "expected a mapping of length 1, but found %s" % subnode.id,
+                        subnode.start_mark)
+            if len(subnode.value) != 1:
+                raise ConstructorError("while constructing pairs", node.start_mark,
+                        "expected a single mapping item, but found %d items" % len(subnode.value),
+                        subnode.start_mark)
+            key_node, value_node = subnode.value[0]
+            key = self.construct_object(key_node)
+            value = self.construct_object(value_node)
+            pairs.append((key, value))
+
+    def construct_yaml_set(self, node):
+        data = set()
+        yield data
+        value = self.construct_mapping(node)
+        data.update(value)
+
+    def construct_yaml_str(self, node):
+        return self.construct_scalar(node)
+
+    def construct_yaml_seq(self, node):
+        data = []
+        yield data
+        data.extend(self.construct_sequence(node))
+
+    def construct_yaml_map(self, node):
+        data = {}
+        yield data
+        value = self.construct_mapping(node)
+        data.update(value)
+
+    def construct_yaml_object(self, node, cls):
+        data = cls.__new__(cls)
+        yield data
+        if hasattr(data, '__setstate__'):
+            state = self.construct_mapping(node, deep=True)
+            data.__setstate__(state)
+        else:
+            state = self.construct_mapping(node)
+            data.__dict__.update(state)
+
+    def construct_undefined(self, node):
+        raise ConstructorError(None, None,
+                "could not determine a constructor for the tag %r" % node.tag,
+                node.start_mark)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:null',
+        SafeConstructor.construct_yaml_null)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:bool',
+        SafeConstructor.construct_yaml_bool)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:int',
+        SafeConstructor.construct_yaml_int)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:float',
+        SafeConstructor.construct_yaml_float)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:binary',
+        SafeConstructor.construct_yaml_binary)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:timestamp',
+        SafeConstructor.construct_yaml_timestamp)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:omap',
+        SafeConstructor.construct_yaml_omap)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:pairs',
+        SafeConstructor.construct_yaml_pairs)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:set',
+        SafeConstructor.construct_yaml_set)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:str',
+        SafeConstructor.construct_yaml_str)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:seq',
+        SafeConstructor.construct_yaml_seq)
+
+SafeConstructor.add_constructor(
+        'tag:yaml.org,2002:map',
+        SafeConstructor.construct_yaml_map)
+
+SafeConstructor.add_constructor(None,
+        SafeConstructor.construct_undefined)
+
+class FullConstructor(SafeConstructor):
+    # 'extend' is blacklisted because it is used by
+    # construct_python_object_apply to add `listitems` to a newly generate
+    # python instance
+    def get_state_keys_blacklist(self):
+        return ['^extend$', '^__.*__$']
+
+    def get_state_keys_blacklist_regexp(self):
+        if not hasattr(self, 'state_keys_blacklist_regexp'):
+            self.state_keys_blacklist_regexp = re.compile('(' + '|'.join(self.get_state_keys_blacklist()) + ')')
+        return self.state_keys_blacklist_regexp
+
+    def construct_python_str(self, node):
+        return self.construct_scalar(node)
+
+    def construct_python_unicode(self, node):
+        return self.construct_scalar(node)
+
+    def construct_python_bytes(self, node):
+        try:
+            value = self.construct_scalar(node).encode('ascii')
+        except UnicodeEncodeError as exc:
+            raise ConstructorError(None, None,
+                    "failed to convert base64 data into ascii: %s" % exc,
+                    node.start_mark)
+        try:
+            if hasattr(base64, 'decodebytes'):
+                return base64.decodebytes(value)
+            else:
+                return base64.decodestring(value)
+        except binascii.Error as exc:
+            raise ConstructorError(None, None,
+                    "failed to decode base64 data: %s" % exc, node.start_mark)
+
+    def construct_python_long(self, node):
+        return self.construct_yaml_int(node)
+
+    def construct_python_complex(self, node):
+       return complex(self.construct_scalar(node))
+
+    def construct_python_tuple(self, node):
+        return tuple(self.construct_sequence(node))
+
+    def find_python_module(self, name, mark, unsafe=False):
+        if not name:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "expected non-empty name appended to the tag", mark)
+        if unsafe:
+            try:
+                __import__(name)
+            except ImportError as exc:
+                raise ConstructorError("while constructing a Python module", mark,
+                        "cannot find module %r (%s)" % (name, exc), mark)
+        if name not in sys.modules:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "module %r is not imported" % name, mark)
+        return sys.modules[name]
+
+    def find_python_name(self, name, mark, unsafe=False):
+        if not name:
+            raise ConstructorError("while constructing a Python object", mark,
+                    "expected non-empty name appended to the tag", mark)
+        if '.' in name:
+            module_name, object_name = name.rsplit('.', 1)
+        else:
+            module_name = 'builtins'
+            object_name = name
+        if unsafe:
+            try:
+                __import__(module_name)
+            except ImportError as exc:
+                raise ConstructorError("while constructing a Python object", mark,
+                        "cannot find module %r (%s)" % (module_name, exc), mark)
+        if module_name not in sys.modules:
+            raise ConstructorError("while constructing a Python object", mark,
+                    "module %r is not imported" % module_name, mark)
+        module = sys.modules[module_name]
+        if not hasattr(module, object_name):
+            raise ConstructorError("while constructing a Python object", mark,
+                    "cannot find %r in the module %r"
+                    % (object_name, module.__name__), mark)
+        return getattr(module, object_name)
+
+    def construct_python_name(self, suffix, node):
+        value = self.construct_scalar(node)
+        if value:
+            raise ConstructorError("while constructing a Python name", node.start_mark,
+                    "expected the empty value, but found %r" % value, node.start_mark)
+        return self.find_python_name(suffix, node.start_mark)
+
+    def construct_python_module(self, suffix, node):
+        value = self.construct_scalar(node)
+        if value:
+            raise ConstructorError("while constructing a Python module", node.start_mark,
+                    "expected the empty value, but found %r" % value, node.start_mark)
+        return self.find_python_module(suffix, node.start_mark)
+
+    def make_python_instance(self, suffix, node,
+            args=None, kwds=None, newobj=False, unsafe=False):
+        if not args:
+            args = []
+        if not kwds:
+            kwds = {}
+        cls = self.find_python_name(suffix, node.start_mark)
+        if not (unsafe or isinstance(cls, type)):
+            raise ConstructorError("while constructing a Python instance", node.start_mark,
+                    "expected a class, but found %r" % type(cls),
+                    node.start_mark)
+        if newobj and isinstance(cls, type):
+            return cls.__new__(cls, *args, **kwds)
+        else:
+            return cls(*args, **kwds)
+
+    def set_python_instance_state(self, instance, state, unsafe=False):
+        if hasattr(instance, '__setstate__'):
+            instance.__setstate__(state)
+        else:
+            slotstate = {}
+            if isinstance(state, tuple) and len(state) == 2:
+                state, slotstate = state
+            if hasattr(instance, '__dict__'):
+                if not unsafe and state:
+                    for key in state.keys():
+                        self.check_state_key(key)
+                instance.__dict__.update(state)
+            elif state:
+                slotstate.update(state)
+            for key, value in slotstate.items():
+                if not unsafe:
+                    self.check_state_key(key)
+                setattr(instance, key, value)
+
+    def construct_python_object(self, suffix, node):
+        # Format:
+        #   !!python/object:module.name { ... state ... }
+        instance = self.make_python_instance(suffix, node, newobj=True)
+        yield instance
+        deep = hasattr(instance, '__setstate__')
+        state = self.construct_mapping(node, deep=deep)
+        self.set_python_instance_state(instance, state)
+
+    def construct_python_object_apply(self, suffix, node, newobj=False):
+        # Format:
+        #   !!python/object/apply       # (or !!python/object/new)
+        #   args: [ ... arguments ... ]
+        #   kwds: { ... keywords ... }
+        #   state: ... state ...
+        #   listitems: [ ... listitems ... ]
+        #   dictitems: { ... dictitems ... }
+        # or short format:
+        #   !!python/object/apply [ ... arguments ... ]
+        # The difference between !!python/object/apply and !!python/object/new
+        # is how an object is created, check make_python_instance for details.
+        if isinstance(node, SequenceNode):
+            args = self.construct_sequence(node, deep=True)
+            kwds = {}
+            state = {}
+            listitems = []
+            dictitems = {}
+        else:
+            value = self.construct_mapping(node, deep=True)
+            args = value.get('args', [])
+            kwds = value.get('kwds', {})
+            state = value.get('state', {})
+            listitems = value.get('listitems', [])
+            dictitems = value.get('dictitems', {})
+        instance = self.make_python_instance(suffix, node, args, kwds, newobj)
+        if state:
+            self.set_python_instance_state(instance, state)
+        if listitems:
+            instance.extend(listitems)
+        if dictitems:
+            for key in dictitems:
+                instance[key] = dictitems[key]
+        return instance
+
+    def construct_python_object_new(self, suffix, node):
+        return self.construct_python_object_apply(suffix, node, newobj=True)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/none',
+    FullConstructor.construct_yaml_null)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/bool',
+    FullConstructor.construct_yaml_bool)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/str',
+    FullConstructor.construct_python_str)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/unicode',
+    FullConstructor.construct_python_unicode)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/bytes',
+    FullConstructor.construct_python_bytes)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/int',
+    FullConstructor.construct_yaml_int)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/long',
+    FullConstructor.construct_python_long)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/float',
+    FullConstructor.construct_yaml_float)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/complex',
+    FullConstructor.construct_python_complex)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/list',
+    FullConstructor.construct_yaml_seq)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/tuple',
+    FullConstructor.construct_python_tuple)
+
+FullConstructor.add_constructor(
+    'tag:yaml.org,2002:python/dict',
+    FullConstructor.construct_yaml_map)
+
+FullConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/name:',
+    FullConstructor.construct_python_name)
+
+class UnsafeConstructor(FullConstructor):
+
+    def find_python_module(self, name, mark):
+        return super(UnsafeConstructor, self).find_python_module(name, mark, unsafe=True)
+
+    def find_python_name(self, name, mark):
+        return super(UnsafeConstructor, self).find_python_name(name, mark, unsafe=True)
+
+    def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False):
+        return super(UnsafeConstructor, self).make_python_instance(
+            suffix, node, args, kwds, newobj, unsafe=True)
+
+    def set_python_instance_state(self, instance, state):
+        return super(UnsafeConstructor, self).set_python_instance_state(
+            instance, state, unsafe=True)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/module:',
+    UnsafeConstructor.construct_python_module)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/object:',
+    UnsafeConstructor.construct_python_object)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/object/new:',
+    UnsafeConstructor.construct_python_object_new)
+
+UnsafeConstructor.add_multi_constructor(
+    'tag:yaml.org,2002:python/object/apply:',
+    UnsafeConstructor.construct_python_object_apply)
+
+# Constructor is same as UnsafeConstructor. Need to leave this in place in case
+# people have extended it directly.
+class Constructor(UnsafeConstructor):
+    pass

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/yaml/cyaml.py

@@ -0,0 +1,101 @@
+
+__all__ = [
+    'CBaseLoader', 'CSafeLoader', 'CFullLoader', 'CUnsafeLoader', 'CLoader',
+    'CBaseDumper', 'CSafeDumper', 'CDumper'
+]
+
+from yaml._yaml import CParser, CEmitter
+
+from .constructor import *
+
+from .serializer import *
+from .representer import *
+
+from .resolver import *
+
+class CBaseLoader(CParser, BaseConstructor, BaseResolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        BaseConstructor.__init__(self)
+        BaseResolver.__init__(self)
+
+class CSafeLoader(CParser, SafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        SafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CFullLoader(CParser, FullConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        FullConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CUnsafeLoader(CParser, UnsafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        UnsafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CLoader(CParser, Constructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
+
+class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class CSafeDumper(CEmitter, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class CDumper(CEmitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+

platform/dbops/archive/databases_old/data/home/x/.local/lib/python3.12/site-packages/invoke/vendor/yaml/dumper.py

@@ -0,0 +1,62 @@
+
+__all__ = ['BaseDumper', 'SafeDumper', 'Dumper']
+
+from .emitter import *
+from .serializer import *
+from .representer import *
+from .resolver import *
+
+class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+
+class Dumper(Emitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=False,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None, sort_keys=True):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style, sort_keys=sort_keys)
+        Resolver.__init__(self)
+