Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-27 02:38
📄 __init__.py import pytest # We need register rewrites before import pytest.register_assert_rewrite("pytest_check.check_functions") from . import check_functions # noqa: E402 # allow for top level helper function access: # import pytest_check # pytest_check.equal(1, 1) from .check_functions import * # noqa: F401, F402, F403, E402 # allow to know if any_failures due to any previous check from .check_log import any_failures # noqa: F401, F402, F403, E402 # allow top level raises: # from pytest_check import raises # with raises(Exception): # raise Exception # with raises(AssertionError): # assert 0 from .check_raises import raises # noqa: F401, F402, F403, E402 # allow for with blocks and assert: # from pytest_check import check # with check: # assert 1 == 2 from .context_manager import check # noqa: F401, F402, F403, E402 # allow check.raises() setattr(check, "raises", raises) # allow check.any_failures() setattr(check, "any_failures", any_failures) # allow check.check as a context manager. # weird, but some people are doing it. # deprecate this eventually setattr(check, "check", check) # allow for helper functions to be part of check context # manager and check fixture: # from pytest_check import check # def test_(): # check.equal(1, 1) # with check: # assert 1 == 2 for func in check_functions.__all__: # noqa: F405 setattr(check, func, getattr(check_functions, func)) # noqa: F405	1.4 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 check_functions.py from __future__ import annotations import functools import sys from typing import ( Any, Callable, Container, Protocol, SupportsFloat, SupportsIndex, TypeVar, Union, ) if sys.version_info < (3, 10): # pragma: no cover from typing_extensions import ParamSpec else: from typing import ParamSpec import pytest import math from .check_log import log_failure __all__ = [ "assert_equal", "equal", "not_equal", "is_", "is_not", "is_true", "is_false", "is_none", "is_not_none", "is_nan", "is_not_nan", "is_in", "is_not_in", "is_instance", "is_not_instance", "almost_equal", "not_almost_equal", "greater", "greater_equal", "less", "less_equal", "between", "between_equal", "check_func", "fail", ] _P = ParamSpec("_P") _T = TypeVar("_T") class _ComparableGreaterThan(Protocol): def __gt__(self, other: Any) -> bool: ... # pragma: no cover class _ComparableGreaterThanOrEqual(Protocol): def __ge__(self, other: Any) -> bool: ... # pragma: no cover class _ComparableLessThan(Protocol): def __lt__(self, other: Any) -> bool: ... # pragma: no cover class _ComparableLessThanOrEqual(Protocol): def __le__(self, other: Any) -> bool: ... # pragma: no cover def check_func(func: Callable[_P, _T]) -> Callable[_P, bool]: @functools.wraps(func) def wrapper(args: _P.args, kwargs: _P.kwargs) -> bool: __tracebackhide__ = True try: func(args, **kwargs) return True except AssertionError as e: log_failure(e) return False return wrapper def assert_equal(a: object, b: object, msg: str = "") -> None: # pragma: no cover assert a == b, msg def equal(a: object, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a == b: return True else: log_failure(f"check {a} == {b}", msg) return False def not_equal(a: object, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a != b: return True else: log_failure(f"check {a} != {b}", msg) return False def is_(a: object, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a is b: return True else: log_failure(f"check {a} is {b}", msg) return False def is_not(a: object, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a is not b: return True else: log_failure(f"check {a} is not {b}", msg) return False def is_true(x: object, msg: str = "") -> bool: __tracebackhide__ = True if bool(x): return True else: log_failure(f"check bool({x})", msg) return False def is_false(x: object, msg: str = "") -> bool: __tracebackhide__ = True if not bool(x): return True else: log_failure(f"check not bool({x})", msg) return False def is_none(x: object, msg: str = "") -> bool: __tracebackhide__ = True if x is None: return True else: log_failure(f"check {x} is None", msg) return False def is_not_none(x: object, msg: str = "") -> bool: __tracebackhide__ = True if x is not None: return True else: log_failure(f"check {x} is not None", msg) return False def is_nan(a: SupportsFloat \| SupportsIndex, msg: str = "") -> bool: __tracebackhide__ = True if math.isnan(a): return True else: log_failure(f"check {a} is NaN", msg) return False def is_not_nan(a: SupportsFloat \| SupportsIndex, msg: str = "") -> bool: __tracebackhide__ = True if not math.isnan(a): return True else: log_failure(f"check {a} is not NaN", msg) return False def is_in(a: _T, b: Container[_T], msg: str = "") -> bool: __tracebackhide__ = True if a in b: return True else: log_failure(f"check {a} in {b}", msg) return False def is_not_in(a: _T, b: Container[_T], msg: str = "") -> bool: __tracebackhide__ = True if a not in b: return True else: log_failure(f"check {a} not in {b}", msg) return False _TypeTuple = Union[type, tuple['_TypeTuple', ...]] def is_instance(a: object, b: _TypeTuple, msg: str = "") -> bool: __tracebackhide__ = True if isinstance(a, b): return True else: log_failure(f"check isinstance({a}, {b})", msg) return False def is_not_instance(a: object, b: _TypeTuple, msg: str = "") -> bool: __tracebackhide__ = True if not isinstance(a, b): return True else: log_failure(f"check not isinstance({a}, {b})", msg) return False def almost_equal( a: object, b: object, rel: Any = None, abs: Any = None, msg: str = "" ) -> bool: """ For rel and abs tolerance, see: See https://docs.pytest.org/en/latest/builtin.html#pytest.approx """ __tracebackhide__ = True if a == pytest.approx(b, rel, abs): return True else: log_failure(f"check {a} == pytest.approx({b}, rel={rel}, abs={abs})", msg) return False def not_almost_equal( a: object, b: object, rel: Any = None, abs: Any = None, msg: str = "" ) -> bool: """ For rel and abs tolerance, see: See https://docs.pytest.org/en/latest/builtin.html#pytest.approx """ __tracebackhide__ = True if a != pytest.approx(b, rel, abs): return True else: log_failure(f"check {a} != pytest.approx({b}, rel={rel}, abs={abs})", msg) return False def greater(a: _ComparableGreaterThan, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a > b: return True else: log_failure(f"check {a} > {b}", msg) return False def greater_equal(a: _ComparableGreaterThanOrEqual, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a >= b: return True else: log_failure(f"check {a} >= {b}", msg) return False def less(a: _ComparableLessThan, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a < b: return True else: log_failure(f"check {a} < {b}", msg) return False def less_equal(a: _ComparableLessThanOrEqual, b: object, msg: str = "") -> bool: __tracebackhide__ = True if a <= b: return True else: log_failure(f"check {a} <= {b}", msg) return False def between( b: Any, a: Any, c: Any, msg: str = "", ge: bool = False, le: bool = False ) -> bool: __tracebackhide__ = True if ge and le: if a <= b <= c: return True else: log_failure(f"check {a} <= {b} <= {c}", msg) return False elif ge: if a <= b < c: return True else: log_failure(f"check {a} <= {b} < {c}", msg) return False elif le: if a < b <= c: return True else: log_failure(f"check {a} < {b} <= {c}", msg) return False else: if a < b < c: return True else: log_failure(f"check {a} < {b} < {c}", msg) return False def between_equal( b: _ComparableLessThanOrEqual, a: _ComparableLessThanOrEqual, c: object, msg:str = "", ) -> bool: __tracebackhide__ = True return between(b, a, c, msg, ge=True, le=True) def fail(msg: str) -> None: __tracebackhide__ = True log_failure(msg)	7.38 KB	2026-01-20 12:58
📄 check_log.py from __future__ import annotations from collections.abc import Iterable from typing import Callable from .pseudo_traceback import _build_pseudo_trace_str should_use_color = False COLOR_RED = "\x1b[31m" COLOR_RESET = "\x1b[0m" _failures: list[str] = [] _stop_on_fail = False _default_max_fail = None _default_max_report = None _default_max_tb = 1 _max_fail: int \| None = _default_max_fail _max_report: int \| None = _default_max_report _max_tb = _default_max_tb _num_failures = 0 _fail_function: Callable[[str], None] \| None = None _showlocals = False def clear_failures() -> None: # gets called at the beginning of each test function global _failures, _num_failures global _max_fail, _max_report, _max_tb _failures = [] _num_failures = 0 _max_fail = _default_max_fail _max_report = _default_max_report _max_tb = _default_max_tb def any_failures() -> bool: return bool(get_failures()) def get_failures() -> list[str]: return _failures def log_failure( msg: object = "", check_str: str = "", tb: Iterable[str] \| None = None ) -> None: global _num_failures __tracebackhide__ = True _num_failures += 1 msg = str(msg).strip() if check_str: msg = f"{msg}: {check_str}" if (_max_report is None) or (_num_failures <= _max_report): if _num_failures <= _max_tb: pseudo_trace_str = _build_pseudo_trace_str(_showlocals, tb, should_use_color) msg = f"{msg}\n{pseudo_trace_str}" if should_use_color: msg = f"{COLOR_RED}FAILURE: {COLOR_RESET}{msg}" else: msg = f"FAILURE: {msg}" _failures.append(msg) if _fail_function: _fail_function(str(msg)) if _max_fail and (_num_failures >= _max_fail): assert_msg = f"pytest-check max fail of {_num_failures} reached" assert _num_failures < _max_fail, assert_msg if _stop_on_fail: assert False, "Stopping on first failure"	2.03 KB	2026-01-20 12:58
📄 check_raises.py from __future__ import annotations from typing import Iterable, Any from .check_log import log_failure _stop_on_fail = False # TODO: Returning Any isn't ideal, but returning CheckRaisesContext \| None # would require callers to type ignore or declare the type when using `with`. # Or, it could always return CheckRaisesContext, just an empty one after # calling the passed function. def raises( expected_exception: type \| Iterable[type], args: Any, kwargs: object ) -> Any: """ Check that a given callable or context raises an error of a given type. Can be used as either a context manager: >>> with raises(AssertionError): >>> raise AssertionError or as a function: >>> def raises_assert(): >>> raise AssertionError >>> raises(AssertionError, raises_assert) `expected_exception` follows the same format rules as the second argument to `issubclass`, so multiple possible exception types can be used. When args[0] is callable, the remainder of args and all of kwargs except for any called `msg` are passed to args[0] as arguments. Note that because `raises` is implemented using a context manager, the usual control flow warnings apply: within the context, execution stops on the first error encountered and does not resume after this error has been logged. Therefore, the line you expect to raise an error must be the last line of the context: any subsequent lines won't be executed. Pull such lines out of the context if they don't raise errors, or use more calls to `raises` if they do. This function is modeled loosely after Pytest's own `raises`, except for the latter's `match`-ing logic. We should strive to keep the call signature of this `raises` as close as possible to the other `raises`. """ __tracebackhide__ = True if isinstance(expected_exception, type): expected_exceptions: Iterable[type] = (expected_exception,) else: expected_exceptions = expected_exception assert all( isinstance(exc, type) or issubclass(exc, BaseException) for exc in expected_exceptions ) msg = kwargs.pop("msg", None) if not args: assert not kwargs, f"Unexpected kwargs for pytest_check.raises: {kwargs}" return CheckRaisesContext(expected_exceptions, msg=msg) else: func = args[0] assert callable(func) with CheckRaisesContext(expected_exceptions, msg=msg): func(args[1:], *kwargs) class CheckRaisesContext: """ Helper context for `raises` that can be parameterized by error type. Note that CheckRaisesContext is instantiated whenever needed; it is not a global variable like `check`. Therefore, we don't need to curate `self.msg` in `__exit__` for this class like we do with CheckContextManager. """ def __init__(self, expected_excs: type, msg: object = None) -> None: self.expected_excs = expected_excs self.msg = msg def __enter__(self) -> "CheckRaisesContext": return self def __exit__(self, exc_type: type, exc_val: object, exc_tb: object) -> bool: __tracebackhide__ = True if exc_type is not None and issubclass(exc_type, self.expected_excs): # This is the case where an error has occured within the context, # but it is the type we're expecting. Therefore, we return True # to silence this error and proceed with execution outside the # context. return True if not _stop_on_fail: # Returning something falsey here will cause the context # manager to not suppress an exception not in # `expected_excs`, thus allowing the higher-level Pytest # context to handle it like any other unhandle exception during # test execution, including display and tracebacks. That is the # behavior we want when `_stop_on_fail` is True, so we let that # case fall through. If not `_stop_on_fail`, then we want to # log the error as a failed check but then continue execution # without raising an error, hence `return True`. log_failure(self.msg if self.msg else exc_val) return True # Stop on fail, so return False return False	4.27 KB	2026-01-20 12:58
📄 context_manager.py from __future__ import annotations import warnings import traceback from types import TracebackType from typing import Callable, Type from . import check_log from .check_log import log_failure _stop_on_fail = False # This class has grown into much more than just a context manager. # it's really the interface into the system. # TODO: maybe rename it # TODO: maybe pull in extra functionality here instead of in plugin.py class CheckContextManager: def __init__(self) -> None: self.msg: object = None def __enter__(self) -> "CheckContextManager": return self def __exit__( self, exc_type: Type[BaseException] \| None, exc_val: BaseException \| None, exc_tb: TracebackType \| None, ) -> bool \| None: __tracebackhide__ = True if exc_type is not None and issubclass(exc_type, AssertionError): if _stop_on_fail: self.msg = None return None else: fmt_tb = traceback.format_exception(exc_type, exc_val, exc_tb) if self.msg is not None: log_failure(f"{exc_val}, {self.msg}", tb=fmt_tb) else: log_failure(exc_val, tb=fmt_tb) self.msg = None return True self.msg = None return None def __call__(self, msg: object = None) -> "CheckContextManager": self.msg = msg return self def set_no_tb(self) -> None: warnings.warn( "set_no_tb() is deprecated; use set_max_tb(0)", DeprecationWarning ) check_log._max_tb = 0 def set_max_fail(self, x: int) -> None: check_log._max_fail = x def set_max_report(self, x: int) -> None: check_log._max_report = x def set_max_tb(self, x: int) -> None: check_log._max_tb = x def call_on_fail(self, func: Callable[[str], None]) -> None: """Experimental feature - may change with any release""" check_log._fail_function = func check = CheckContextManager()	2.03 KB	2026-01-20 12:58
📄 plugin.py import sys import os from typing import Generator, TYPE_CHECKING import pytest from pytest import CallInfo, Config, Item, Parser, TestReport from _pytest.skipping import xfailed_key from _pytest._code.code import ( ExceptionChainRepr, ExceptionInfo, ExceptionRepr, ReprFileLocation, ) if TYPE_CHECKING: # pragma: no cover from pluggy import Result from . import check_log, check_raises, context_manager, pseudo_traceback from .context_manager import CheckContextManager @pytest.hookimpl(hookwrapper=True, trylast=True) def pytest_runtest_makereport( item: Item, call: CallInfo[None] ) -> "Generator[None, Result[TestReport], None]": outcome: "Result[TestReport]" = yield report: TestReport = outcome.get_result() num_failures = check_log._num_failures failures = check_log.get_failures() check_log.clear_failures() if failures: xfailed_value = item._store.get(xfailed_key, None) if xfailed_value and not item.config.option.runxfail: report.outcome = "skipped" report.wasxfail = xfailed_value.reason else: summary = f"Failed Checks: {num_failures}" longrepr = ["\n".join(failures)] longrepr.append("-" * 60) longrepr.append(summary) if report.longrepr: longrepr.append("-" * 60) longrepr.append(report.longreprtext) report.longrepr = "\n".join(longrepr) else: report.longrepr = "\n".join(longrepr) report.outcome = "failed" try: raise AssertionError(report.longrepr) except AssertionError as e: excinfo = ExceptionInfo.from_current() if (pytest.version_tuple >= (7,3,0) and not os.getenv('PYTEST_XDIST_WORKER')): # Build a summary report with failure reason # Depends on internals of pytest, which changed in 7.3 # Also, doesn't work with xdist # # Example: Before 7.3: # =========== short test summary info =========== # FAILED test_example_simple.py::test_fail # Example after 7.3: # =========== short test summary info =========== # FAILED test_example_simple.py::test_fail - assert 1 == 2 # e_str = str(e) e_str = e_str.split('FAILURE: ')[1] # Remove redundant "Failure: " reprcrash = ReprFileLocation(item.nodeid, 0, e_str) # FIXME - the next two lines have broken types reprtraceback = ExceptionRepr(reprcrash, excinfo) # type: ignore chain_repr = ExceptionChainRepr([(reprtraceback, reprcrash, str(e))]) # type: ignore report.longrepr = chain_repr else: # pragma: no cover # coverage is run on latest pytest # we'll have one test run on an older pytest just to make sure # it works. ... call.excinfo = excinfo def pytest_configure(config: Config) -> None: # Add some red to the failure output, if stdout can accommodate it. isatty = sys.stdout.isatty() color = getattr(config.option, "color", None) check_log.should_use_color = (isatty and color == "auto") or (color == "yes") # If -x or --maxfail=1, then stop on the first failed check # Otherwise, let pytest stop on the maxfail-th test function failure maxfail = config.getvalue("maxfail") stop_on_fail = maxfail == 1 # TODO: perhaps centralize where we're storing stop_on_fail context_manager._stop_on_fail = stop_on_fail check_raises._stop_on_fail = stop_on_fail check_log._stop_on_fail = stop_on_fail # Allow for --tb=no to turn off check's pseudo tbs traceback_style = config.getoption("tbstyle", default=None) pseudo_traceback._traceback_style = traceback_style check_log._showlocals = config.getoption("showlocals", default=None) # grab options check_log._default_max_fail = config.getoption("--check-max-fail") check_log._default_max_report = config.getoption("--check-max-report") check_log._default_max_tb = config.getoption("--check-max-tb") # Allow for tests to grab "check" via fixture: # def test_a(check): # check.equal(a, b) @pytest.fixture(name="check") def check_fixture() -> CheckContextManager: return context_manager.check # add some options def pytest_addoption(parser: Parser) -> None: parser.addoption( "--check-max-report", action="store", type=int, help="max failures to report", ) parser.addoption( "--check-max-fail", action="store", type=int, help="max failures per test", ) parser.addoption( "--check-max-tb", action="store", type=int, default=1, help="max pseudo-tracebacks per test", )	5.01 KB	2026-01-20 12:58
📄 pseudo_traceback.py from __future__ import annotations import inspect import os import re import sys from collections.abc import Iterable from inspect import FrameInfo from pprint import pformat from typing import AnyStr, Any if sys.version_info < (3, 11): # pragma: no cover from typing_extensions import LiteralString else: from typing import LiteralString _traceback_style = "auto" def get_full_context( frame: FrameInfo ) -> tuple[AnyStr \| LiteralString, Any, Any, str, Any, bool]: (_, filename, line, funcname, contextlist) = frame[0:5] locals_ = frame.frame.f_locals tb_hide = locals_.get("__tracebackhide__", False) try: filename = os.path.relpath(filename) except ValueError: # pragma: no cover # this is necessary if we're tracing to a different drive letter # such as C: to D: # # Turning off coverage for abspath, for now, # since that path requires testing with an odd setup. # But.... we'll keep looking for a way to test it. :) filename = os.path.abspath(filename) # pragma: no cover context = contextlist[0].strip() if contextlist else "" return filename, line, funcname, context, locals_, tb_hide COLOR_RED = "\x1b[31m" COLOR_RESET = "\x1b[0m" def reformat_raw_traceback(lines: Iterable[str], color: bool) -> str: formatted: list[str] = [] for line in lines: if 'Traceback (most recent call last)' in line: continue if 'AssertionError' in line: if color: line = f"{COLOR_RED}{line}{COLOR_RESET}" formatted.append(line) continue result = re.search(r'File "(.)", line (.), in (\w)$\n\W(.*)', line, flags=re.MULTILINE) if result: file_path, line_no, func_name, context = result.groups() file_name = os.path.basename(file_path) if color: file_name = f"{COLOR_RED}{file_name}{COLOR_RESET}" #formatted.append(f'{file_name}:{line_no} in {func_name}\n {context}') formatted.append(f'{file_name}:{line_no} in {func_name} -> {context}') else: # I don't have a test case to hit this clause yet # And I can't think of one. # But it feels weird to not have the if/else. # Thus, the "no cover" formatted.append(line) # pragma: no cover return '\n'.join(formatted) def _build_pseudo_trace_str( showlocals: bool, tb: Iterable[str] \| None, color: bool ) -> str: """ built traceback styles for better error message only supports no """ if _traceback_style == "no": return "" skip_own_frames = 3 pseudo_trace = [] func = "" if tb: pseudo_trace.append(reformat_raw_traceback(tb, color)) context_stack = inspect.stack()[skip_own_frames:] while "test_" not in func and context_stack: full_context = get_full_context(context_stack.pop(0)) (file, line, func, context, locals, tb_hide) = full_context # we want to trace through user code, not 3rd party or builtin libs if "site-packages" in file: break # if called outside a test, we might hit this if "<module>" in func: break if tb_hide: continue if showlocals: for name, val in reversed(locals.items()): if not name.startswith('@py'): pseudo_trace.append("%-10s = %s" % (name, pformat(val, sort_dicts=False, compact=True))) if color: file = f"{COLOR_RED}{file}{COLOR_RESET}" #line = f"{file}:{line} in {func}\n {context}" line = f"{file}:{line} in {func}() -> {context}" pseudo_trace.append(line) return "\n".join(reversed(pseudo_trace)) + "\n"	3.88 KB	2026-01-20 12:58
📄 py.typed	0 B	2026-01-20 12:58

Terminal