ULTRA [ growontech.com ]

Linux premium216.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64

LiteSpeed

66.29.141.148 | Your IP: 3.144.123.24

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / hc_python / lib / python3.8 / site-packages /

Home Upload Mass Deface Mass Delete Back Connect Notify

xmltodict.py

#!/usr/bin/env python
"Makes working with XML feel like you are working with JSON"

try:
    from defusedexpat import pyexpat as expat
except ImportError:
    from xml.parsers import expat
from xml.sax.saxutils import XMLGenerator
from xml.sax.xmlreader import AttributesImpl
try:  # pragma no cover
    from cStringIO import StringIO
except ImportError:  # pragma no cover
    try:
        from StringIO import StringIO
    except ImportError:
        from io import StringIO

_dict = dict
import platform
if tuple(map(int, platform.python_version_tuple()[:2])) < (3, 7):
 from collections import OrderedDict as _dict

from inspect import isgenerator

try:  # pragma no cover
    _basestring = basestring
except NameError:  # pragma no cover
    _basestring = str
try:  # pragma no cover
    _unicode = unicode
except NameError:  # pragma no cover
    _unicode = str

__author__ = 'Martin Blech'
__version__ = '0.13.0'
__license__ = 'MIT'

class ParsingInterrupted(Exception):
    pass

class _DictSAXHandler(object):
    def __init__(self,
                 item_depth=0,
                 item_callback=lambda *args: True,
                 xml_attribs=True,
                 attr_prefix='@',
                 cdata_key='#text',
                 force_cdata=False,
                 cdata_separator='',
                 postprocessor=None,
                 dict_constructor=_dict,
                 strip_whitespace=True,
                 namespace_separator=':',
                 namespaces=None,
                 force_list=None,
                 comment_key='#comment'):
        self.path = []
        self.stack = []
        self.data = []
        self.item = None
        self.item_depth = item_depth
        self.xml_attribs = xml_attribs
        self.item_callback = item_callback
        self.attr_prefix = attr_prefix
        self.cdata_key = cdata_key
        self.force_cdata = force_cdata
        self.cdata_separator = cdata_separator
        self.postprocessor = postprocessor
        self.dict_constructor = dict_constructor
        self.strip_whitespace = strip_whitespace
        self.namespace_separator = namespace_separator
        self.namespaces = namespaces
        self.namespace_declarations = dict_constructor()
        self.force_list = force_list
        self.comment_key = comment_key

def _build_name(self, full_name):
        if self.namespaces is None:
            return full_name
        i = full_name.rfind(self.namespace_separator)
        if i == -1:
            return full_name
        namespace, name = full_name[:i], full_name[i+1:]
        try:
            short_namespace = self.namespaces[namespace]
        except KeyError:
            short_namespace = namespace
        if not short_namespace:
            return name
        else:
            return self.namespace_separator.join((short_namespace, name))

def _attrs_to_dict(self, attrs):
        if isinstance(attrs, dict):
            return attrs
        return self.dict_constructor(zip(attrs[0::2], attrs[1::2]))

def startNamespaceDecl(self, prefix, uri):
        self.namespace_declarations[prefix or ''] = uri

def startElement(self, full_name, attrs):
        name = self._build_name(full_name)
        attrs = self._attrs_to_dict(attrs)
        if attrs and self.namespace_declarations:
            attrs['xmlns'] = self.namespace_declarations
            self.namespace_declarations = self.dict_constructor()
        self.path.append((name, attrs or None))
        if len(self.path) > self.item_depth:
            self.stack.append((self.item, self.data))
            if self.xml_attribs:
                attr_entries = []
                for key, value in attrs.items():
                    key = self.attr_prefix+self._build_name(key)
                    if self.postprocessor:
                        entry = self.postprocessor(self.path, key, value)
                    else:
                        entry = (key, value)
                    if entry:
                        attr_entries.append(entry)
                attrs = self.dict_constructor(attr_entries)
            else:
                attrs = None
            self.item = attrs or None
            self.data = []

def endElement(self, full_name):
        name = self._build_name(full_name)
        if len(self.path) == self.item_depth:
            item = self.item
            if item is None:
                item = (None if not self.data
                        else self.cdata_separator.join(self.data))

should_continue = self.item_callback(self.path, item)
            if not should_continue:
                raise ParsingInterrupted()
        if self.stack:
            data = (None if not self.data
                    else self.cdata_separator.join(self.data))
            item = self.item
            self.item, self.data = self.stack.pop()
            if self.strip_whitespace and data:
                data = data.strip() or None
            if data and self.force_cdata and item is None:
                item = self.dict_constructor()
            if item is not None:
                if data:
                    self.push_data(item, self.cdata_key, data)
                self.item = self.push_data(self.item, name, item)
            else:
                self.item = self.push_data(self.item, name, data)
        else:
            self.item = None
            self.data = []
        self.path.pop()

def characters(self, data):
        if not self.data:
            self.data = [data]
        else:
            self.data.append(data)

def comments(self, data):
        if self.strip_whitespace:
            data = data.strip()
        self.item = self.push_data(self.item, self.comment_key, data)

def push_data(self, item, key, data):
        if self.postprocessor is not None:
            result = self.postprocessor(self.path, key, data)
            if result is None:
                return item
            key, data = result
        if item is None:
            item = self.dict_constructor()
        try:
            value = item[key]
            if isinstance(value, list):
                value.append(data)
            else:
                item[key] = [value, data]
        except KeyError:
            if self._should_force_list(key, data):
                item[key] = [data]
            else:
                item[key] = data
        return item

def _should_force_list(self, key, value):
        if not self.force_list:
            return False
        if isinstance(self.force_list, bool):
            return self.force_list
        try:
            return key in self.force_list
        except TypeError:
            return self.force_list(self.path[:-1], key, value)

def parse(xml_input, encoding=None, expat=expat, process_namespaces=False,
          namespace_separator=':', disable_entities=True, process_comments=False, **kwargs):
    """Parse the given XML input and convert it into a dictionary.

`xml_input` can either be a `string`, a file-like object, or a generator of strings.

If `xml_attribs` is `True`, element attributes are put in the dictionary
    among regular child elements, using `@` as a prefix to avoid collisions. If
    set to `False`, they are just ignored.

Simple example::

>>> import xmltodict
 >>> doc = xmltodict.parse(\"\"\"
 ... <a prop="x">
 ... 1
 ... 2
 ... </a>
 ... \"\"\")
 >>> doc['a']['@prop']
 u'x'
 >>> doc['a']['b']
 [u'1', u'2']

If `item_depth` is `0`, the function returns a dictionary for the root
    element (default behavior). Otherwise, it calls `item_callback` every time
    an item at the specified depth is found and returns `None` in the end
    (streaming mode).

The callback function receives two parameters: the `path` from the document
    root to the item (name-attribs pairs), and the `item` (dict). If the
    callback's return value is false-ish, parsing will be stopped with the
    :class:`ParsingInterrupted` exception.

Streaming example::

>>> def handle(path, item):
 ... print('path:%s item:%s' % (path, item))
 ... return True
 ...
 >>> xmltodict.parse(\"\"\"
 ... <a prop="x">
 ... 1
 ... 2
 ... </a>\"\"\", item_depth=2, item_callback=handle)
 path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:1
 path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:2

The optional argument `postprocessor` is a function that takes `path`,
    `key` and `value` as positional arguments and returns a new `(key, value)`
    pair where both `key` and `value` may have changed. Usage example::

>>> def postprocessor(path, key, value):
 ... try:
 ... return key + ':int', int(value)
 ... except (ValueError, TypeError):
 ... return key, value
 >>> xmltodict.parse('<a>12x</a>',
 ... postprocessor=postprocessor)
 {'a': {'b:int': [1, 2], 'b': 'x'}}

You can pass an alternate version of `expat` (such as `defusedexpat`) by
    using the `expat` parameter. E.g:

>>> import defusedexpat
 >>> xmltodict.parse('<a>hello</a>', expat=defusedexpat.pyexpat)
 {'a': 'hello'}

You can use the force_list argument to force lists to be created even
    when there is only a single child of a given level of hierarchy. The
    force_list argument is a tuple of keys. If the key for a given level
    of hierarchy is in the force_list argument, that level of hierarchy
    will have a list as a child (even if there is only one sub-element).
    The index_keys operation takes precedence over this. This is applied
    after any user-supplied postprocessor has already run.

For example, given this input:
 <servers>
 <server>
 <name>host1</name>
 <os>Linux</os>
 <interfaces>
 <interface>
 <name>em0</name>
 <ip_address>10.0.0.1</ip_address>
 </interface>
 </interfaces>
 </server>
 </servers>

If called with force_list=('interface',), it will produce
        this dictionary:
        {'servers':
          {'server':
            {'name': 'host1',
             'os': 'Linux'},
             'interfaces':
              {'interface':
                [ {'name': 'em0', 'ip_address': '10.0.0.1' } ] } } }

`force_list` can also be a callable that receives `path`, `key` and
        `value`. This is helpful in cases where the logic that decides whether
        a list should be forced is more complex.

If `process_comment` is `True` then comment will be added with comment_key
        (default=`'#comment'`) to then tag which contains comment

For example, given this input:
 <a>
 
 
 <c>
 
 1
 </c>
 <d>2</d>
 
 </a>

If called with process_comment=True, it will produce
            this dictionary:
            'a': {
                'b': {
                    '#comment': 'b comment',
                    'c': {

'#comment': 'c comment',
                        '#text': '1',
                    },
                    'd': '2',
                },
            }
    """
    handler = _DictSAXHandler(namespace_separator=namespace_separator,
                              **kwargs)
    if isinstance(xml_input, _unicode):
        if not encoding:
            encoding = 'utf-8'
        xml_input = xml_input.encode(encoding)
    if not process_namespaces:
        namespace_separator = None
    parser = expat.ParserCreate(
        encoding,
        namespace_separator
    )
    try:
        parser.ordered_attributes = True
    except AttributeError:
        # Jython's expat does not support ordered_attributes
        pass
    parser.StartNamespaceDeclHandler = handler.startNamespaceDecl
    parser.StartElementHandler = handler.startElement
    parser.EndElementHandler = handler.endElement
    parser.CharacterDataHandler = handler.characters
    if process_comments:
        parser.CommentHandler = handler.comments
    parser.buffer_text = True
    if disable_entities:
        try:
            # Attempt to disable DTD in Jython's expat parser (Xerces-J).
            feature = "http://apache.org/xml/features/disallow-doctype-decl"
            parser._reader.setFeature(feature, True)
        except AttributeError:
            # For CPython / expat parser.
            # Anything not handled ends up here and entities aren't expanded.
            parser.DefaultHandler = lambda x: None
            # Expects an integer return; zero means failure -> expat.ExpatError.
            parser.ExternalEntityRefHandler = lambda *x: 1
    if hasattr(xml_input, 'read'):
        parser.ParseFile(xml_input)
    elif isgenerator(xml_input):
        for chunk in xml_input:
            parser.Parse(chunk,False)
        parser.Parse(b'',True)
    else:
        parser.Parse(xml_input, True)
    return handler.item

def _process_namespace(name, namespaces, ns_sep=':', attr_prefix='@'):
    if not namespaces:
        return name
    try:
        ns, name = name.rsplit(ns_sep, 1)
    except ValueError:
        pass
    else:
        ns_res = namespaces.get(ns.strip(attr_prefix))
        name = '{}{}{}{}'.format(
            attr_prefix if ns.startswith(attr_prefix) else '',
            ns_res, ns_sep, name) if ns_res else name
    return name

def _emit(key, value, content_handler,
          attr_prefix='@',
          cdata_key='#text',
          depth=0,
          preprocessor=None,
          pretty=False,
          newl='\n',
          indent='\t',
          namespace_separator=':',
          namespaces=None,
          full_document=True,
          expand_iter=None):
    key = _process_namespace(key, namespaces, namespace_separator, attr_prefix)
    if preprocessor is not None:
        result = preprocessor(key, value)
        if result is None:
            return
        key, value = result
    if (not hasattr(value, '__iter__')
            or isinstance(value, _basestring)
            or isinstance(value, dict)):
        value = [value]
    for index, v in enumerate(value):
        if full_document and depth == 0 and index > 0:
            raise ValueError('document with multiple roots')
        if v is None:
            v = _dict()
        elif isinstance(v, bool):
            if v:
                v = _unicode('true')
            else:
                v = _unicode('false')
        elif not isinstance(v, dict):
            if expand_iter and hasattr(v, '__iter__') and not isinstance(v, _basestring):
                v = _dict(((expand_iter, v),))
            else:
                v = _unicode(v)
        if isinstance(v, _basestring):
            v = _dict(((cdata_key, v),))
        cdata = None
        attrs = _dict()
        children = []
        for ik, iv in v.items():
            if ik == cdata_key:
                cdata = iv
                continue
            if ik.startswith(attr_prefix):
                ik = _process_namespace(ik, namespaces, namespace_separator,
                                        attr_prefix)
                if ik == '@xmlns' and isinstance(iv, dict):
                    for k, v in iv.items():
                        attr = 'xmlns{}'.format(':{}'.format(k) if k else '')
                        attrs[attr] = _unicode(v)
                    continue
                if not isinstance(iv, _unicode):
                    iv = _unicode(iv)
                attrs[ik[len(attr_prefix):]] = iv
                continue
            children.append((ik, iv))
        if pretty:
            content_handler.ignorableWhitespace(depth * indent)
        content_handler.startElement(key, AttributesImpl(attrs))
        if pretty and children:
            content_handler.ignorableWhitespace(newl)
        for child_key, child_value in children:
            _emit(child_key, child_value, content_handler,
                  attr_prefix, cdata_key, depth+1, preprocessor,
                  pretty, newl, indent, namespaces=namespaces,
                  namespace_separator=namespace_separator,
                  expand_iter=expand_iter)
        if cdata is not None:
            content_handler.characters(cdata)
        if pretty and children:
            content_handler.ignorableWhitespace(depth * indent)
        content_handler.endElement(key)
        if pretty and depth:
            content_handler.ignorableWhitespace(newl)

def unparse(input_dict, output=None, encoding='utf-8', full_document=True,
            short_empty_elements=False,
            **kwargs):
    """Emit an XML document for the given `input_dict` (reverse of `parse`).

The resulting XML document is returned as a string, but if `output` (a
    file-like object) is specified, it is written there instead.

Dictionary keys prefixed with `attr_prefix` (default=`'@'`) are interpreted
    as XML node attributes, whereas keys equal to `cdata_key`
    (default=`'#text'`) are treated as character data.

The `pretty` parameter (default=`False`) enables pretty-printing. In this
    mode, lines are terminated with `'\n'` and indented with `'\t'`, but this
    can be customized with the `newl` and `indent` parameters.

"""
    if full_document and len(input_dict) != 1:
        raise ValueError('Document must have exactly one root.')
    must_return = False
    if output is None:
        output = StringIO()
        must_return = True
    if short_empty_elements:
        content_handler = XMLGenerator(output, encoding, True)
    else:
        content_handler = XMLGenerator(output, encoding)
    if full_document:
        content_handler.startDocument()
    for key, value in input_dict.items():
        _emit(key, value, content_handler, full_document=full_document,
              **kwargs)
    if full_document:
        content_handler.endDocument()
    if must_return:
        value = output.getvalue()
        try:  # pragma no cover
            value = value.decode(encoding)
        except AttributeError:  # pragma no cover
            pass
        return value

if __name__ == '__main__':  # pragma: no cover
    import sys
    import marshal
    try:
        stdin = sys.stdin.buffer
        stdout = sys.stdout.buffer
    except AttributeError:
        stdin = sys.stdin
        stdout = sys.stdout

(item_depth,) = sys.argv[1:]
    item_depth = int(item_depth)

def handle_item(path, item):
        marshal.dump((path, item), stdout)
        return True

try:
        root = parse(stdin,
                     item_depth=item_depth,
                     item_callback=handle_item,
                     dict_constructor=dict)
        if item_depth == 0:
            handle_item([], root)
    except KeyboardInterrupt:
        pass

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2024-10-22 05:00:48
..	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:34
Mako-1.3.2.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:43
MarkupSafe-2.1.5.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:25
MySQLdb	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:23
PyYAML-6.0.2.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
SQLAlchemy-2.0.32.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:24
__pycache__	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:33
_distutils_hack	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:41
_yaml	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
aenum	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:15
aenum-3.1.15.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:16
alembic	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:27
alembic-1.13.2.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:27
annotated_types	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
annotated_types-0.7.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
cfgv-3.4.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:34
charset_normalizer	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:32
charset_normalizer-3.3.2.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:33
curl	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:52
dict2xml	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
dict2xml-1.7.6.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
dicttoxml-1.7.16.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:32
distlib	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:15
distlib-0.3.8.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:15
distro	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:30
distro-1.9.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:30
dns	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
dnspython-2.6.1.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
filelock	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:28
filelock-3.13.1.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:29
greenlet	dir	-	root/root	drwxr-xr-x	2024-10-08 05:04:23
greenlet-3.1.1.dist-info	dir	-	root/root	drwxr-xr-x	2024-10-08 05:04:23
identify	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:27
identify-2.5.35.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:27
idna	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:26
idna-3.6.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:27
importlib_metadata	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:44
importlib_metadata-7.1.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:44
importlib_resources	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:43
importlib_resources-6.3.2.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:44
inotify	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:26
inotify-0.2.10.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:26
lxml	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:25
lxml-5.1.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:26
mako	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:42
markupsafe	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:24
mysql	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:14
mysql-0.0.3.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:42
mysql_connector-2.2.9.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:15
mysqlclient-2.2.4.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:24
mysqlx	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:14
nodeenv-1.8.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:23
nose	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:13
nose-1.3.7.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:14
pip	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:15
pip-24.2.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:16
pkg_resources	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:41
platformdirs	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:22
platformdirs-4.2.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:23
pre_commit	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:46
pre_commit-3.5.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:46
prometheus_client	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
prometheus_client-0.20.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
psutil	dir	-	root/root	drwxr-xr-x	2024-10-22 05:00:48
psutil-6.1.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-10-22 05:00:48
pycurl-7.45.3.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:53
pycurl.libs	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:52
pydantic	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
pydantic-2.8.2.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:27
pydantic_core	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
pydantic_core-2.20.1.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
pyone	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
pyone-6.8.3.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:26
requests	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:24
requests-2.32.3.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
sentry_sdk	dir	-	root/root	drwxr-xr-x	2024-10-22 05:00:47
sentry_sdk-2.17.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-10-22 05:00:47
setuptools	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:41
setuptools-58.3.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:28:42
sqlalchemy	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:23
tblib	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:19
tblib-3.0.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:19
typing_extensions-4.10.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:19
urllib3	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:17
urllib3-2.2.1.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:18
virtualenv	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:34
virtualenv-20.25.1.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:35
wheel	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:23
wheel-0.44.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:23
xmltodict-0.13.0.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:17
yaml	dir	-	root/root	drwxr-xr-x	2024-08-19 05:31:25
zipp	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:16
zipp-3.18.1.dist-info	dir	-	root/root	drwxr-xr-x	2024-03-21 10:33:16
cfgv.py	text/x-script.python	11.93 KB	root/root	-rw-r--r--	2024-03-21 10:33:33
dicttoxml.py	text/x-script.python	14.65 KB	root/root	-rw-r--r--	2024-03-21 10:33:30
distutils-precedence.pth	text/plain	152 B	root/root	-rw-r--r--	2024-03-21 10:28:40
nodeenv.py	text/x-script.python	45.35 KB	root/root	-rw-r--r--	2024-03-21 10:33:23
pycurl.cpython-38-x86_64-linux-gnu.so	application/x-pie-executable	673.49 KB	root/root	-rwxr-xr-x	2024-03-21 10:28:52
typing_extensions.py	text/x-script.python	114.84 KB	root/root	-rw-r--r--	2024-03-21 10:33:18
xmltodict.py	text/x-script.python	18.65 KB	root/root	-rw-r--r--	2024-03-21 10:33:16