Zy Filemanager

📁 File Browser

Name	Size	Permissions	Actions
📁 __pycache__	DIR	0755	🗑️
📄 __init__.py (2,946 bytes)	2.88 KB	0644	✍️ ⬇️ 🗑️
📄 _hypothesis_plugin.py (14,847 bytes)	14.5 KB	0644	✍️ ⬇️ 🗑️
📄 annotated_types.py (3,157 bytes)	3.08 KB	0644	✍️ ⬇️ 🗑️
📄 class_validators.py (14,672 bytes)	14.33 KB	0644	✍️ ⬇️ 🗑️
📄 color.py (16,844 bytes)	16.45 KB	0644	✍️ ⬇️ 🗑️
📄 config.py (6,532 bytes)	6.38 KB	0644	✍️ ⬇️ 🗑️
📄 dataclasses.py (18,172 bytes)	17.75 KB	0644	✍️ ⬇️ 🗑️
📄 datetime_parse.py (7,724 bytes)	7.54 KB	0644	✍️ ⬇️ 🗑️
📄 decorator.py (10,339 bytes)	10.1 KB	0644	✍️ ⬇️ 🗑️
📄 env_settings.py (14,105 bytes)	13.77 KB	0644	✍️ ⬇️ 🗑️
📄 error_wrappers.py (5,196 bytes)	5.07 KB	0644	✍️ ⬇️ 🗑️
📄 errors.py (17,726 bytes)	17.31 KB	0644	✍️ ⬇️ 🗑️
📄 fields.py (50,649 bytes)	49.46 KB	0644	✍️ ⬇️ 🗑️
📄 generics.py (17,871 bytes)	17.45 KB	0644	✍️ ⬇️ 🗑️
📄 json.py (3,390 bytes)	3.31 KB	0644	✍️ ⬇️ 🗑️
📄 main.py (44,541 bytes)	43.5 KB	0644	✍️ ⬇️ 🗑️
📄 mypy.py (38,774 bytes)	37.87 KB	0644	✍️ ⬇️ 🗑️
📄 networks.py (22,124 bytes)	21.61 KB	0644	✍️ ⬇️ 🗑️
📄 parse.py (1,821 bytes)	1.78 KB	0644	✍️ ⬇️ 🗑️
📄 py.typed (0 bytes)	0 B	0644	✍️ ⬇️ 🗑️
📄 schema.py (47,760 bytes)	46.64 KB	0644	✍️ ⬇️ 🗑️
📄 tools.py (2,881 bytes)	2.81 KB	0644	✍️ ⬇️ 🗑️
📄 types.py (35,455 bytes)	34.62 KB	0644	✍️ ⬇️ 🗑️
📄 typing.py (19,387 bytes)	18.93 KB	0644	✍️ ⬇️ 🗑️
📄 utils.py (25,919 bytes)	25.31 KB	0644	✍️ ⬇️ 🗑️
📄 validators.py (21,996 bytes)	21.48 KB	0644	✍️ ⬇️ 🗑️
📄 version.py (1,039 bytes)	1.01 KB	0644	✍️ ⬇️ 🗑️

✍️ Editing: error_wrappers.py

            File: /opt/hc_python/lib/python3.12/site-packages/pydantic/v1/error_wrappers.py

            Size: 5.07 KB | 
            Last Modified: 2025-04-04 15:08:41        

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

from pydantic.v1.json import pydantic_encoder
from pydantic.v1.utils import Representation

if TYPE_CHECKING:
    from typing_extensions import TypedDict

from pydantic.v1.config import BaseConfig
    from pydantic.v1.types import ModelOrDc
    from pydantic.v1.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

↩️ Back

Zy Filemanager

📁 File Browser

📤 Upload Files

Single File

Multiple Files

ZIP Extract

➕ Create New

New Folder

New File

✍️ Editing: error_wrappers.py

Backup Management