golden hour

/opt/saltstack/salt/lib/python3.10/site-packages/salt/utils

File/Folder	Size	Actions
__init__.py	237 B
__pycache__	-
aggregation.py	5.17 KB
ansible.py	1.48 KB
args.py	18.33 KB
asynchronous.py	4.06 KB
atomicfile.py	5.33 KB
aws.py	20.37 KB
azurearm.py	11.42 KB
beacons.py	517 B
boto3mod.py	8.36 KB
boto_elb_tag.py	3.02 KB
botomod.py	7.98 KB
cache.py	11.49 KB
channel.py	489 B
cloud.py	116.3 KB
color.py	2.72 KB
compat.py	1.89 KB
configcomparer.py	3.88 KB
configparser.py	10.82 KB
context.py	6.8 KB
crypt.py	5 KB
ctx.py	1.42 KB
data.py	53.03 KB
dateutils.py	2.3 KB
debug.py	4.19 KB
decorators	-
dictdiffer.py	16.48 KB
dicttrim.py	3.9 KB
dictupdate.py	11.33 KB
dns.py	35.21 KB
doc.py	2.25 KB
dockermod	-
entrypoints.py	1.83 KB
environment.py	2.2 KB
error.py	1.18 KB
etcd_util.py	33.25 KB
event.py	52.45 KB
extend.py	8.87 KB
extmods.py	6.04 KB
filebuffer.py	3.15 KB
files.py	27.94 KB
find.py	22.08 KB
fsutils.py	3.29 KB
functools.py	6.02 KB
gitfs.py	130.41 KB
github.py	1.52 KB
gzip_util.py	2.86 KB
hashutils.py	5.91 KB
http.py	33.9 KB
iam.py	1.22 KB
icinga2.py	754 B
idem.py	1.22 KB
immutabletypes.py	2.46 KB
itertools.py	2.36 KB
jid.py	3 KB
jinja.py	33.92 KB
job.py	6.89 KB
json.py	3.78 KB
kickstart.py	41.04 KB
kinds.py	493 B
lazy.py	3.06 KB
listdiffer.py	10.9 KB
locales.py	2.06 KB
mac_utils.py	14.01 KB
mako.py	3.97 KB
master.py	29.7 KB
mattermost.py	1.77 KB
memcached.py	3.56 KB
migrations.py	1.46 KB
mine.py	3.68 KB
minion.py	4.13 KB
minions.py	43.38 KB
mount.py	1.15 KB
msazure.py	5.36 KB
msgpack.py	4.69 KB
nacl.py	13.65 KB
namecheap.py	4.32 KB
napalm.py	23.22 KB
nb_popen.py	7.24 KB
network.py	73.86 KB
nxos.py	12.94 KB
nxos_api.py	4 KB
odict.py	13.21 KB
openstack	-
oset.py	6.41 KB
pagerduty.py	3.03 KB
parsers.py	122.69 KB
path.py	11.24 KB
pbm.py	9.81 KB
pkg	-
platform.py	5.84 KB
powershell.py	4.15 KB
preseed.py	2.64 KB
process.py	40.76 KB
profile.py	3.21 KB
proxy.py	331 B
psutil_compat.py	3.63 KB
pushover.py	4.51 KB
pycrypto.py	5.41 KB
pydsl.py	13.74 KB
pyobjects.py	10.75 KB
reactor.py	18.99 KB
reclass.py	752 B
roster_matcher.py	3.55 KB
rsax931.py	8.42 KB
s3.py	8.78 KB
saltclass.py	14.27 KB
sanitizers.py	2.51 KB
schedule.py	71.81 KB
schema.py	54.26 KB
sdb.py	4.04 KB
slack.py	3.58 KB
smb.py	11.16 KB
smtp.py	3.27 KB
ssdp.py	14.75 KB
ssh.py	769 B
state.py	8.43 KB
stringio.py	355 B
stringutils.py	16.95 KB
systemd.py	5.51 KB
templates.py	24.03 KB
textformat.py	5.03 KB
thin.py	31.91 KB
timed_subprocess.py	4.06 KB
timeout.py	1.53 KB
timeutil.py	2.4 KB
url.py	5 KB
user.py	11.86 KB
validate	-
value.py	247 B
vault.py	21.74 KB
verify.py	25.34 KB
versions.py	17.17 KB
virt.py	3.24 KB
virtualbox.py	22.43 KB
vmware.py	129.74 KB
vsan.py	17.18 KB
vt.py	31.47 KB
vt_helper.py	4.4 KB
win_chcp.py	3.7 KB
win_dacl.py	95.49 KB
win_dotnet.py	4.74 KB
win_functions.py	12.69 KB
win_lgpo_auditpol.py	8.48 KB
win_lgpo_netsh.py	17.87 KB
win_lgpo_reg.py	16.98 KB
win_network.py	16.35 KB
win_osinfo.py	2.83 KB
win_pdh.py	13.85 KB
win_reg.py	30.82 KB
win_runas.py	10.53 KB
win_service.py	5.2 KB
win_system.py	14.47 KB
win_update.py	40.36 KB
winapi.py	818 B
x509.py	73.19 KB
xdg.py	316 B
xmlutil.py	13.91 KB
yaml.py	349 B
yamldumper.py	3.37 KB
yamlencoding.py	1.55 KB
yamllint.py	1.61 KB
yamlloader.py	6.04 KB
yamlloader_old.py	8.15 KB
yast.py	619 B
zeromq.py	1.74 KB
zfs.py	19.15 KB

Edit: odict.py

"""
    :codeauthor: Pedro Algarvio (pedro@algarvio.me)

salt.utils.odict
    ~~~~~~~~~~~~~~~~

This is a compatibility/"importability" layer for an ordered dictionary.
    Tries to import from the standard library if python >= 2.7, then from the
    ``ordereddict`` package available from PyPi, and, as a last resort,
    provides an ``OrderedDict`` implementation based on::

http://code.activestate.com/recipes/576669/

It also implements a DefaultOrderedDict Class that serves  as a
    combination of ``OrderedDict`` and ``defaultdict``
    It's source was submitted here::

http://stackoverflow.com/questions/6190331/
"""

# pragma: no cover  # essentially using Python's OrderDict

from collections.abc import Callable

try:
    # pylint: disable=E0611,minimum-python-version
    import collections

class OrderedDict(collections.OrderedDict):
        __hash__ = None

except (ImportError, AttributeError):
    try:
        import ordereddict

class OrderedDict(ordereddict.OrderedDict):  # pylint: disable=W0232
            __hash_ = None

except ImportError:
        # {{{ http://code.activestate.com/recipes/576693/ (r9)
        # Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
        # Passes Python2.7's test suite and incorporates all the latest updates.

try:
            from _thread import get_ident as _get_ident
        except ImportError:
            from _dummy_thread import get_ident as _get_ident

#        try:
        #            from _abcoll import KeysView, ValuesView, ItemsView
        #        except ImportError:
        #            pass

class OrderedDict(dict):
            "Dictionary that remembers insertion order"
            # An inherited dict maps keys to values.
            # The inherited dict provides __getitem__, __len__, __contains__, and get.
            # The remaining methods are order-aware.
            # Big-O running times for all methods are the same as for regular dictionaries.

# The internal self.__map dictionary maps keys to links in a doubly linked list.
            # The circular doubly linked list starts and ends with a sentinel element.
            # The sentinel element never gets deleted (this simplifies the algorithm).
            # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
            __hash_ = None

def __init__(self, *args, **kwds):  # pylint: disable=E1003
                """Initialize an ordered dictionary.  Signature is the same as for
                regular dictionaries, but keyword arguments are not recommended
                because their insertion order is arbitrary.

"""
                super().__init__()
                if len(args) > 1:
                    raise TypeError(
                        "expected at most 1 arguments, got {}".format(len(args))
                    )
                try:
                    self.__root
                except AttributeError:
                    self.__root = root = []  # sentinel node
                    root[:] = [root, root, None]
                    self.__map = {}
                self.__update(*args, **kwds)

def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
                "od.__setitem__(i, y) <==> od[i]=y"
                # Setting a new item creates a new link which goes at the end of the linked
                # list, and the inherited dictionary is updated with the new key/value pair.
                if key not in self:
                    root = self.__root
                    last = root[0]
                    last[1] = root[0] = self.__map[key] = [last, root, key]
                dict_setitem(self, key, value)

def __delitem__(self, key, dict_delitem=dict.__delitem__):
                "od.__delitem__(y) <==> del od[y]"
                # Deleting an existing item uses self.__map to find the link which is
                # then removed by updating the links in the predecessor and successor nodes.
                dict_delitem(self, key)
                link_prev, link_next, key = self.__map.pop(key)
                link_prev[1] = link_next
                link_next[0] = link_prev

def __iter__(self):
                "od.__iter__() <==> iter(od)"
                root = self.__root
                curr = root[1]
                while curr is not root:
                    yield curr[2]
                    curr = curr[1]

def __reversed__(self):
                "od.__reversed__() <==> reversed(od)"
                root = self.__root
                curr = root[0]
                while curr is not root:
                    yield curr[2]
                    curr = curr[0]

def clear(self):
                "od.clear() -> None.  Remove all items from od."
                try:
                    for node in self.__map.values():
                        del node[:]
                    root = self.__root
                    root[:] = [root, root, None]
                    self.__map.clear()
                except AttributeError:
                    pass
                dict.clear(self)

def popitem(self, last=True):
                """od.popitem() -> (k, v), return and remove a (key, value) pair.
                Pairs are returned in LIFO order if last is true or FIFO order if false.

"""
                if not self:
                    raise KeyError("dictionary is empty")
                root = self.__root
                if last:
                    link = root[0]
                    link_prev = link[0]
                    link_prev[1] = root
                    root[0] = link_prev
                else:
                    link = root[1]
                    link_next = link[1]
                    root[1] = link_next
                    link_next[0] = root
                key = link[2]
                del self.__map[key]
                value = dict.pop(self, key)
                return key, value

# -- the following methods do not depend on the internal structure --

def keys(self):
                "od.keys() -> list of keys in od"
                return list(self)

def values(self):
                "od.values() -> list of values in od"
                return [self[key] for key in self]

def items(self):
                "od.items() -> list of (key, value) pairs in od"
                return [(key, self[key]) for key in self]

def iterkeys(self):
                "od.iterkeys() -> an iterator over the keys in od"
                return iter(self)

def itervalues(self):
                "od.itervalues -> an iterator over the values in od"
                for k in self:
                    yield self[k]

def iteritems(self):
                "od.iteritems -> an iterator over the (key, value) items in od"
                for k in self:
                    yield (k, self[k])

def update(*args, **kwds):  # pylint: disable=E0211
                """od.update(E, **F) -> None.  Update od from dict/iterable E and F.

If E is a dict instance, does:           for k in E: od[k] = E[k]
                If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
                Or if E is an iterable of items, does:   for k, v in E: od[k] = v
                In either case, this is followed by:     for k, v in F.items(): od[k] = v

"""
                if len(args) > 2:
                    raise TypeError(
                        "update() takes at most 2 positional "
                        "arguments ({} given)".format(len(args))
                    )
                elif not args:
                    raise TypeError("update() takes at least 1 argument (0 given)")
                self = args[0]
                # Make progressively weaker assumptions about "other"
                other = ()
                if len(args) == 2:
                    other = args[1]
                if isinstance(other, dict):
                    for key in other:
                        self[key] = other[key]
                elif hasattr(other, "keys"):
                    for key in other:
                        self[key] = other[key]
                else:
                    for key, value in other:
                        self[key] = value
                for key, value in kwds.items():
                    self[key] = value

__update = (
                update  # let subclasses override update without breaking __init__
            )

__marker = object()

def pop(self, key, default=__marker):
                """od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
                If key is not found, d is returned if given, otherwise KeyError is raised.

"""
                if key in self:
                    result = self[key]
                    del self[key]
                    return result
                if default is self.__marker:
                    raise KeyError(key)
                return default

def setdefault(self, key, default=None):
                "od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od"
                if key in self:
                    return self[key]
                self[key] = default
                return default

def __repr__(self, _repr_running={}):  # pylint: disable=W0102
                "od.__repr__() <==> repr(od)"
                call_key = id(self), _get_ident()
                if call_key in _repr_running:
                    return "..."
                _repr_running[call_key] = 1
                try:
                    if not self:
                        return "{}()".format(self.__class__.__name__)
                    return "{}('{}')".format(
                        self.__class__.__name__, list(self.items())
                    )
                finally:
                    del _repr_running[call_key]

def __reduce__(self):
                "Return state information for pickling"
                items = [[k, self[k]] for k in self]
                inst_dict = vars(self).copy()
                for k in vars(OrderedDict()):
                    inst_dict.pop(k, None)
                if inst_dict:
                    return (self.__class__, (items,), inst_dict)
                return self.__class__, (items,)

def copy(self):
                "od.copy() -> a shallow copy of od"
                return self.__class__(self)

@classmethod
            def fromkeys(cls, iterable, value=None):
                """OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
                and values equal to v (which defaults to None).

"""
                d = cls()
                for key in iterable:
                    d[key] = value
                return d

def __eq__(self, other):
                """od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
                while comparison to a regular mapping is order-insensitive.

"""
                if isinstance(other, OrderedDict):
                    return len(self) == len(other) and self.items() == other.items()
                return dict.__eq__(self, other)

def __ne__(self, other):
                return not self == other

#            # -- the following methods are only used in Python 2.7 --
#
#            def viewkeys(self):
#                "od.viewkeys() -> a set-like object providing a view on od's keys"
#                return KeysView(self)
#
#            def viewvalues(self):
#                "od.viewvalues() -> an object providing a view on od's values"
#                return ValuesView(self)
#
#            def viewitems(self):
#                "od.viewitems() -> a set-like object providing a view on od's items"
#                return ItemsView(self)
#        ## end of http://code.activestate.com/recipes/576693/ }}}

class DefaultOrderedDict(OrderedDict):
    """
    Dictionary that remembers insertion order
    """

def __init__(self, default_factory=None, *a, **kw):
        if default_factory is not None and not isinstance(default_factory, Callable):
            raise TypeError("first argument must be callable")
        super().__init__(*a, **kw)
        self.default_factory = default_factory

def __getitem__(self, key):
        try:
            return OrderedDict.__getitem__(self, key)
        except KeyError:
            return self.__missing__(key)

def __missing__(self, key):
        if self.default_factory is None:
            raise KeyError(key)
        self[key] = value = self.default_factory()
        return value

def __reduce__(self):
        if self.default_factory is None:
            args = tuple()
        else:
            args = (self.default_factory,)
        return type(self), args, None, None, self.items()

def copy(self):
        return self.__copy__()

def __copy__(self):
        return type(self)(self.default_factory, self)

def __deepcopy__(self):
        import copy

return type(self)(self.default_factory, copy.deepcopy(self.items()))

def __repr__(self, _repr_running={}):  # pylint: disable=W0102
        return "DefaultOrderedDict({}, {})".format(
            self.default_factory, super().__repr__()
        )