Graybyt3 Was Here

Linux host74.registrar-servers.com 4.18.0-553.lve.el8.x86_64 #1 SMP Mon May 27 15:27:34 UTC 2024 x86_64
Apache
162.213.253.119

File Name : error_wrappers.py

import json
from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Sequence, Tuple, Type, Union

from .json import pydantic_encoder
from .utils import Representation

if TYPE_CHECKING:
    from typing_extensions import TypedDict

from .config import BaseConfig
    from .types import ModelOrDc
    from .typing import ReprArgs

Loc = Tuple[Union[int, str], ...]

class _ErrorDictRequired(TypedDict):
        loc: Loc
        msg: str
        type: str

class ErrorDict(_ErrorDictRequired, total=False):
        ctx: Dict[str, Any]

__all__ = 'ErrorWrapper', 'ValidationError'

class ErrorWrapper(Representation):
    __slots__ = 'exc', '_loc'

def __init__(self, exc: Exception, loc: Union[str, 'Loc']) -> None:
        self.exc = exc
        self._loc = loc

def loc_tuple(self) -> 'Loc':
        if isinstance(self._loc, tuple):
            return self._loc
        else:
            return (self._loc,)

def __repr_args__(self) -> 'ReprArgs':
        return [('exc', self.exc), ('loc', self.loc_tuple())]

# ErrorList is something like Union[List[Union[List[ErrorWrapper], ErrorWrapper]], ErrorWrapper]
# but recursive, therefore just use:
ErrorList = Union[Sequence[Any], ErrorWrapper]

class ValidationError(Representation, ValueError):
    __slots__ = 'raw_errors', 'model', '_error_cache'

def __init__(self, errors: Sequence[ErrorList], model: 'ModelOrDc') -> None:
        self.raw_errors = errors
        self.model = model
        self._error_cache: Optional[List['ErrorDict']] = None

def errors(self) -> List['ErrorDict']:
        if self._error_cache is None:
            try:
                config = self.model.__config__  # type: ignore
            except AttributeError:
                config = self.model.__pydantic_model__.__config__  # type: ignore
            self._error_cache = list(flatten_errors(self.raw_errors, config))
        return self._error_cache

def json(self, *, indent: Union[None, int, str] = 2) -> str:
        return json.dumps(self.errors(), indent=indent, default=pydantic_encoder)

def __str__(self) -> str:
        errors = self.errors()
        no_errors = len(errors)
        return (
            f'{no_errors} validation error{"" if no_errors == 1 else "s"} for {self.model.__name__}\n'
            f'{display_errors(errors)}'
        )

def __repr_args__(self) -> 'ReprArgs':
        return [('model', self.model.__name__), ('errors', self.errors())]

def display_errors(errors: List['ErrorDict']) -> str:
    return '\n'.join(f'{_display_error_loc(e)}\n  {e["msg"]} ({_display_error_type_and_ctx(e)})' for e in errors)

def _display_error_loc(error: 'ErrorDict') -> str:
    return ' -> '.join(str(e) for e in error['loc'])

def _display_error_type_and_ctx(error: 'ErrorDict') -> str:
    t = 'type=' + error['type']
    ctx = error.get('ctx')
    if ctx:
        return t + ''.join(f'; {k}={v}' for k, v in ctx.items())
    else:
        return t

def flatten_errors(
    errors: Sequence[Any], config: Type['BaseConfig'], loc: Optional['Loc'] = None
) -> Generator['ErrorDict', None, None]:
    for error in errors:
        if isinstance(error, ErrorWrapper):

if loc:
                error_loc = loc + error.loc_tuple()
            else:
                error_loc = error.loc_tuple()

if isinstance(error.exc, ValidationError):
                yield from flatten_errors(error.exc.raw_errors, config, error_loc)
            else:
                yield error_dict(error.exc, config, error_loc)
        elif isinstance(error, list):
            yield from flatten_errors(error, config, loc=loc)
        else:
            raise RuntimeError(f'Unknown error object: {error}')

def error_dict(exc: Exception, config: Type['BaseConfig'], loc: 'Loc') -> 'ErrorDict':
    type_ = get_exc_type(exc.__class__)
    msg_template = config.error_msg_templates.get(type_) or getattr(exc, 'msg_template', None)
    ctx = exc.__dict__
    if msg_template:
        msg = msg_template.format(**ctx)
    else:
        msg = str(exc)

d: 'ErrorDict' = {'loc': loc, 'msg': msg, 'type': type_}

if ctx:
        d['ctx'] = ctx

return d

_EXC_TYPE_CACHE: Dict[Type[Exception], str] = {}

def get_exc_type(cls: Type[Exception]) -> str:
    # slightly more efficient than using lru_cache since we don't need to worry about the cache filling up
    try:
        return _EXC_TYPE_CACHE[cls]
    except KeyError:
        r = _get_exc_type(cls)
        _EXC_TYPE_CACHE[cls] = r
        return r

def _get_exc_type(cls: Type[Exception]) -> str:
    if issubclass(cls, AssertionError):
        return 'assertion_error'

base_name = 'type_error' if issubclass(cls, TypeError) else 'value_error'
    if cls in (TypeError, ValueError):
        # just TypeError or ValueError, no extra code
        return base_name

# if it's not a TypeError or ValueError, we just take the lowercase of the exception name
    # no chaining or snake case logic, use "code" for more complex error types.
    code = getattr(cls, 'code', None) or cls.__name__.replace('Error', '').lower()
    return base_name + '.' + code

System Information
*ReClick For Close
File : BlackDragon /wp-content/uploads/2019/09/hq95bs/index.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2024-04-17 01:36:23
..	dir	-	root/root	0755	2024-04-17 01:36:23
__pycache__	dir	-	root/root	0755	2024-04-17 01:36:23
__init__.py	text/x-python	2.71 KB	root/root	0644	2024-04-17 01:36:23
_hypothesis_plugin.py	text/plain	14.5 KB	root/root	0644	2024-04-17 01:36:23
annotated_types.py	text/x-python	3.05 KB	root/root	0644	2024-04-17 01:36:23
class_validators.py	text/x-python	14.25 KB	root/root	0644	2024-04-17 01:36:23
color.py	text/plain	16.42 KB	root/root	0644	2024-04-17 01:36:23
config.py	text/x-python	6.33 KB	root/root	0644	2024-04-17 01:36:23
dataclasses.py	text/plain	17.1 KB	root/root	0644	2024-04-17 01:36:23
datetime_parse.py	text/plain	7.53 KB	root/root	0644	2024-04-17 01:36:23
decorator.py	text/x-python	10.02 KB	root/root	0644	2024-04-17 01:36:23
env_settings.py	text/x-python	13.71 KB	root/root	0644	2024-04-17 01:36:23
error_wrappers.py	text/x-python	5.02 KB	root/root	0644	2024-04-17 01:36:23
errors.py	text/x-python	17.28 KB	root/root	0644	2024-04-17 01:36:23
fields.py	text/x-python	49.3 KB	root/root	0644	2024-04-17 01:36:23
generics.py	text/x-python	17.39 KB	root/root	0644	2024-04-17 01:36:23
json.py	text/x-python	3.27 KB	root/root	0644	2024-04-17 01:36:23
main.py	text/x-python	43.34 KB	root/root	0644	2024-04-17 01:36:23
mypy.py	text/x-python	37.84 KB	root/root	0644	2024-04-17 01:36:23
networks.py	text/x-python	21.54 KB	root/root	0644	2024-04-17 01:36:23
parse.py	text/x-python	1.77 KB	root/root	0644	2024-04-17 01:36:23
py.typed	application/x-empty	0 B	root/root	0644	2024-04-17 01:36:23
schema.py	text/x-python	46.5 KB	root/root	0644	2024-04-17 01:36:23
tools.py	text/x-python	2.76 KB	root/root	0644	2024-04-17 01:36:23
types.py	text/x-python	34.55 KB	root/root	0644	2024-04-17 01:36:23
typing.py	text/x-python	18.55 KB	root/root	0644	2024-04-17 01:36:23
utils.py	text/x-python	25.2 KB	root/root	0644	2024-04-17 01:36:23
validators.py	text/x-python	21.37 KB	root/root	0644	2024-04-17 01:36:23
version.py	text/x-python	1.01 KB	root/root	0644	2024-04-17 01:36:23