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: 18.221.12.61

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

cfgv.py

from __future__ import annotations

import collections
import contextlib
import os.path
import re
import sys

class ValidationError(ValueError):
    def __init__(self, error_msg, ctx=None):
        super().__init__(error_msg)
        self.error_msg = error_msg
        self.ctx = ctx

def __str__(self):
        out = '\n'
        err = self
        while err.ctx is not None:
            out += f'==> {err.ctx}\n'
            err = err.error_msg
        out += f'=====> {err.error_msg}'
        return out

MISSING = collections.namedtuple('Missing', ())()
type(MISSING).__repr__ = lambda self: 'MISSING'

@contextlib.contextmanager
def validate_context(msg):
    try:
        yield
    except ValidationError as e:
        _, _, tb = sys.exc_info()
        raise ValidationError(e, ctx=msg).with_traceback(tb) from None

@contextlib.contextmanager
def reraise_as(tp):
    try:
        yield
    except ValidationError as e:
        _, _, tb = sys.exc_info()
        raise tp(e).with_traceback(tb) from None

def _dct_noop(self, dct):
    pass

def _check_optional(self, dct):
    if self.key not in dct:
        return
    with validate_context(f'At key: {self.key}'):
        self.check_fn(dct[self.key])

def _apply_default_optional(self, dct):
    dct.setdefault(self.key, self.default)

def _remove_default_optional(self, dct):
    if dct.get(self.key, MISSING) == self.default:
        del dct[self.key]

def _require_key(self, dct):
    if self.key not in dct:
        raise ValidationError(f'Missing required key: {self.key}')

def _check_required(self, dct):
    _require_key(self, dct)
    _check_optional(self, dct)

@property
def _check_fn_recurse(self):
    def check_fn(val):
        validate(val, self.schema)
    return check_fn

def _apply_default_required_recurse(self, dct):
    dct[self.key] = apply_defaults(dct[self.key], self.schema)

def _remove_default_required_recurse(self, dct):
    dct[self.key] = remove_defaults(dct[self.key], self.schema)

def _apply_default_optional_recurse(self, dct):
    if self.key not in dct:
        _apply_default_optional(self, dct)
    _apply_default_required_recurse(self, dct)

def _remove_default_optional_recurse(self, dct):
    if self.key in dct:
        _remove_default_required_recurse(self, dct)
        _remove_default_optional(self, dct)

def _get_check_conditional(inner):
    def _check_conditional(self, dct):
        if dct.get(self.condition_key, MISSING) == self.condition_value:
            inner(self, dct)
        elif (
                self.condition_key in dct and
                self.ensure_absent and self.key in dct
        ):
            if hasattr(self.condition_value, 'describe_opposite'):
                explanation = self.condition_value.describe_opposite()
            else:
                explanation = f'is not {self.condition_value!r}'
            raise ValidationError(
                f'Expected {self.key} to be absent when {self.condition_key} '
                f'{explanation}, found {self.key}: {dct[self.key]!r}',
            )
    return _check_conditional

def _apply_default_conditional_optional(self, dct):
    if dct.get(self.condition_key, MISSING) == self.condition_value:
        _apply_default_optional(self, dct)

def _remove_default_conditional_optional(self, dct):
    if dct.get(self.condition_key, MISSING) == self.condition_value:
        _remove_default_optional(self, dct)

def _apply_default_conditional_recurse(self, dct):
    if dct.get(self.condition_key, MISSING) == self.condition_value:
        _apply_default_required_recurse(self, dct)

def _remove_default_conditional_recurse(self, dct):
    if dct.get(self.condition_key, MISSING) == self.condition_value:
        _remove_default_required_recurse(self, dct)

def _no_additional_keys_check(self, dct):
    extra = sorted(set(dct) - set(self.keys))
    if extra:
        extra_s = ', '.join(str(x) for x in extra)
        keys_s = ', '.join(str(x) for x in self.keys)
        raise ValidationError(
            f'Additional keys found: {extra_s}.  '
            f'Only these keys are allowed: {keys_s}',
        )

def _warn_additional_keys_check(self, dct):
    extra = sorted(set(dct) - set(self.keys))
    if extra:
        self.callback(extra, self.keys, dct)

Required = collections.namedtuple('Required', ('key', 'check_fn'))
Required.check = _check_required
Required.apply_default = _dct_noop
Required.remove_default = _dct_noop
RequiredRecurse = collections.namedtuple('RequiredRecurse', ('key', 'schema'))
RequiredRecurse.check = _check_required
RequiredRecurse.check_fn = _check_fn_recurse
RequiredRecurse.apply_default = _apply_default_required_recurse
RequiredRecurse.remove_default = _remove_default_required_recurse
Optional = collections.namedtuple('Optional', ('key', 'check_fn', 'default'))
Optional.check = _check_optional
Optional.apply_default = _apply_default_optional
Optional.remove_default = _remove_default_optional
OptionalRecurse = collections.namedtuple(
    'OptionalRecurse', ('key', 'schema', 'default'),
)
OptionalRecurse.check = _check_optional
OptionalRecurse.check_fn = _check_fn_recurse
OptionalRecurse.apply_default = _apply_default_optional_recurse
OptionalRecurse.remove_default = _remove_default_optional_recurse
OptionalNoDefault = collections.namedtuple(
    'OptionalNoDefault', ('key', 'check_fn'),
)
OptionalNoDefault.check = _check_optional
OptionalNoDefault.apply_default = _dct_noop
OptionalNoDefault.remove_default = _dct_noop
Conditional = collections.namedtuple(
    'Conditional',
    ('key', 'check_fn', 'condition_key', 'condition_value', 'ensure_absent'),
)
Conditional.__new__.__defaults__ = (False,)
Conditional.check = _get_check_conditional(_check_required)
Conditional.apply_default = _dct_noop
Conditional.remove_default = _dct_noop
ConditionalOptional = collections.namedtuple(
    'ConditionalOptional',
    (
        'key', 'check_fn', 'default', 'condition_key', 'condition_value',
        'ensure_absent',
    ),
)
ConditionalOptional.__new__.__defaults__ = (False,)
ConditionalOptional.check = _get_check_conditional(_check_optional)
ConditionalOptional.apply_default = _apply_default_conditional_optional
ConditionalOptional.remove_default = _remove_default_conditional_optional
ConditionalRecurse = collections.namedtuple(
    'ConditionalRecurse',
    ('key', 'schema', 'condition_key', 'condition_value', 'ensure_absent'),
)
ConditionalRecurse.__new__.__defaults__ = (False,)
ConditionalRecurse.check = _get_check_conditional(_check_required)
ConditionalRecurse.check_fn = _check_fn_recurse
ConditionalRecurse.apply_default = _apply_default_conditional_recurse
ConditionalRecurse.remove_default = _remove_default_conditional_recurse
NoAdditionalKeys = collections.namedtuple('NoAdditionalKeys', ('keys',))
NoAdditionalKeys.check = _no_additional_keys_check
NoAdditionalKeys.apply_default = _dct_noop
NoAdditionalKeys.remove_default = _dct_noop
WarnAdditionalKeys = collections.namedtuple(
    'WarnAdditionalKeys', ('keys', 'callback'),
)
WarnAdditionalKeys.check = _warn_additional_keys_check
WarnAdditionalKeys.apply_default = _dct_noop
WarnAdditionalKeys.remove_default = _dct_noop

class Map(collections.namedtuple('Map', ('object_name', 'id_key', 'items'))):
    __slots__ = ()

def __new__(cls, object_name, id_key, *items):
        return super().__new__(cls, object_name, id_key, items)

def check(self, v):
        if not isinstance(v, dict):
            raise ValidationError(
                f'Expected a {self.object_name} map but got a '
                f'{type(v).__name__}',
            )
        if self.id_key is None:
            context = f'At {self.object_name}()'
        else:
            key_v_s = v.get(self.id_key, MISSING)
            context = f'At {self.object_name}({self.id_key}={key_v_s!r})'
        with validate_context(context):
            for item in self.items:
                item.check(v)

def apply_defaults(self, v):
        ret = v.copy()
        for item in self.items:
            item.apply_default(ret)
        return ret

def remove_defaults(self, v):
        ret = v.copy()
        for item in self.items:
            item.remove_default(ret)
        return ret

class Array(collections.namedtuple('Array', ('of', 'allow_empty'))):
    __slots__ = ()

def __new__(cls, of, allow_empty=True):
        return super().__new__(cls, of=of, allow_empty=allow_empty)

def check(self, v):
        check_array(check_any)(v)
        if not self.allow_empty and not v:
            raise ValidationError(
                f"Expected at least 1 '{self.of.object_name}'",
            )
        for val in v:
            validate(val, self.of)

def apply_defaults(self, v):
        return [apply_defaults(val, self.of) for val in v]

def remove_defaults(self, v):
        return [remove_defaults(val, self.of) for val in v]

class Not(collections.namedtuple('Not', ('val',))):
    __slots__ = ()

def describe_opposite(self):
        return f'is {self.val!r}'

def __eq__(self, other):
        return other is not MISSING and other != self.val

class NotIn(collections.namedtuple('NotIn', ('values',))):
    __slots__ = ()

def __new__(cls, *values):
        return super().__new__(cls, values=values)

def describe_opposite(self):
        return f'is any of {self.values!r}'

def __eq__(self, other):
        return other is not MISSING and other not in self.values

class In(collections.namedtuple('In', ('values',))):
    __slots__ = ()

def __new__(cls, *values):
        return super().__new__(cls, values=values)

def describe_opposite(self):
        return f'is not any of {self.values!r}'

def __eq__(self, other):
        return other is not MISSING and other in self.values

def check_any(_):
    pass

def check_type(tp, typename=None):
    def check_type_fn(v):
        if not isinstance(v, tp):
            typename_s = typename or tp.__name__
            raise ValidationError(
                f'Expected {typename_s} got {type(v).__name__}',
            )
    return check_type_fn

check_bool = check_type(bool)
check_bytes = check_type(bytes)
check_int = check_type(int)
check_string = check_type(str, typename='string')
check_text = check_type(str, typename='text')

def check_one_of(possible):
    def check_one_of_fn(v):
        if v not in possible:
            possible_s = ', '.join(str(x) for x in sorted(possible))
            raise ValidationError(
                f'Expected one of {possible_s} but got: {v!r}',
            )
    return check_one_of_fn

def check_regex(v):
    try:
        re.compile(v)
    except re.error:
        raise ValidationError(f'{v!r} is not a valid python regex')

def check_array(inner_check):
    def check_array_fn(v):
        if not isinstance(v, (list, tuple)):
            raise ValidationError(
                f'Expected array but got {type(v).__name__!r}',
            )

for i, val in enumerate(v):
            with validate_context(f'At index {i}'):
                inner_check(val)
    return check_array_fn

def check_and(*fns):
    def check(v):
        for fn in fns:
            fn(v)
    return check

def validate(v, schema):
    schema.check(v)
    return v

def apply_defaults(v, schema):
    return schema.apply_defaults(v)

def remove_defaults(v, schema):
    return schema.remove_defaults(v)

def load_from_filename(
        filename,
        schema,
        load_strategy,
        exc_tp=ValidationError,
        *,
        display_filename=None,
):
    display_filename = display_filename or filename
    with reraise_as(exc_tp):
        if not os.path.isfile(filename):
            raise ValidationError(f'{display_filename} is not a file')

with validate_context(f'File {display_filename}'):
            try:
                with open(filename, encoding='utf-8') as f:
                    contents = f.read()
            except UnicodeDecodeError as e:
                raise ValidationError(str(e))

try:
                data = load_strategy(contents)
            except Exception as e:
                raise ValidationError(str(e))

validate(data, schema)
            return apply_defaults(data, schema)

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