shell bypass 403
UnknownSec Shell
:
/
opt
/
cloudlinux
/
venv
/
lib
/
python3.11
/
site-packages
/
testfixtures
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
datetime.py
from calendar import timegm from datetime import datetime, timedelta, date, tzinfo as TZInfo from typing import Optional, Callable, Type, Tuple, Dict, Any, cast, overload class Queue(list): delta: float delta_delta: float delta_type: str def __init__(self, delta: Optional[float], delta_delta: float, delta_type: str): super().__init__() if delta is None: self.delta = 0 self.delta_delta = delta_delta else: self.delta = delta self.delta_delta = 0 self.delta_type = delta_type def advance_next(self, delta: timedelta) -> None: self[-1] += delta def next(self) -> 'MockedCurrent': instance = self.pop(0) if not self: self.delta += self.delta_delta n = instance + timedelta(**{self.delta_type: self.delta}) self.append(n) return instance class MockedCurrent: _mock_queue: Queue _mock_base_class: Type _mock_class: Type _mock_tzinfo: Optional[TZInfo] _mock_date_type: Type[date] _correct_mock_type: Callable = None def __init_subclass__( cls, concrete: bool = False, queue: Queue = None, strict: bool = None, tzinfo: TZInfo = None, date_type: Type[date] = None ): if concrete: cls._mock_queue = queue cls._mock_base_class = cls.__bases__[0].__bases__[1] cls._mock_class = cls if strict else cls._mock_base_class cls._mock_tzinfo = tzinfo cls._mock_date_type = date_type @classmethod def add(cls, *args, **kw): if 'tzinfo' in kw or len(args) > 7: raise TypeError('Cannot add using tzinfo on %s' % cls.__name__) if args and isinstance(args[0], cls._mock_base_class): instance = args[0] instance_tzinfo = getattr(instance, 'tzinfo', None) if instance_tzinfo: if instance_tzinfo != cls._mock_tzinfo: raise ValueError( 'Cannot add %s with tzinfo of %s as configured to use %s' % ( instance.__class__.__name__, instance_tzinfo, cls._mock_tzinfo )) instance = instance.replace(tzinfo=None) if cls._correct_mock_type: instance = cls._correct_mock_type(instance) else: instance = cls(*args, **kw) cls._mock_queue.append(instance) @classmethod def set(cls, *args, **kw) -> None: cls._mock_queue.clear() cls.add(*args, **kw) @classmethod def tick(cls, *args, **kw) -> None: if kw: delta = timedelta(**kw) else: delta, = args cls._mock_queue.advance_next(delta) def __add__(self, other) -> 'MockedCurrent': instance = super().__add__(other) if self._correct_mock_type: instance = self._correct_mock_type(instance) return instance def __new__(cls, *args, **kw): if cls is cls._mock_class: return super().__new__(cls, *args, **kw) else: return cls._mock_class(*args, **kw) def mock_factory( type_name: str, mock_class: Type[MockedCurrent], default: Tuple[int, ...], args: tuple, kw: Dict[str, Any], delta: Optional[float], delta_type: str, delta_delta: float = 1, date_type: Type[date] = None, tzinfo: TZInfo = None, strict: bool = False ): cls = cast(Type[MockedCurrent], type( type_name, (mock_class,), {}, concrete=True, queue=Queue(delta, delta_delta, delta_type), strict=strict, tzinfo=tzinfo, date_type=date_type, )) if args != (None,): if not (args or kw): args = default cls.add(*args, **kw) return cls class MockDateTime(MockedCurrent, datetime): @overload @classmethod def add( cls, year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: TZInfo = ..., ) -> None: ... @overload @classmethod def add( cls, instance: datetime, ) -> None: ... @classmethod def add(cls, *args, **kw): """ This will add the :class:`datetime.datetime` created from the supplied parameters to the queue of datetimes to be returned by :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ return super().add(*args, **kw) @overload @classmethod def set( cls, year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: TZInfo = ..., ) -> None: ... @overload @classmethod def set( cls, instance: datetime, ) -> None: ... @classmethod def set(cls, *args, **kw): """ This will set the :class:`datetime.datetime` created from the supplied parameters as the next datetime to be returned by :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`, clearing out any datetimes in the queue. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ return super().set(*args, **kw) @overload @classmethod def tick( cls, days: float = ..., seconds: float = ..., microseconds: float = ..., milliseconds: float = ..., minutes: float = ..., hours: float = ..., weeks: float = ..., ) -> None: ... @overload @classmethod def tick( cls, delta: timedelta, # can become positional-only when Python 3.8 minimum ) -> None: ... @classmethod def tick(cls, *args, **kw) -> None: """ This method should be called either with a :class:`~datetime.timedelta` as a positional argument, or with keyword parameters that will be used to construct a :class:`~datetime.timedelta`. The :class:`~datetime.timedelta` will be used to advance the next datetime to be returned by :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`. """ return super().tick(*args, **kw) @classmethod def _correct_mock_type(cls, instance): return cls._mock_class( instance.year, instance.month, instance.day, instance.hour, instance.minute, instance.second, instance.microsecond, instance.tzinfo, ) @classmethod def now(cls, tz: TZInfo = None) -> datetime: """ :param tz: An optional timezone to apply to the returned time. If supplied, it must be an instance of a :class:`~datetime.tzinfo` subclass. This will return the next supplied or calculated datetime from the internal queue, rather than the actual current datetime. If `tz` is supplied, see :ref:`timezones`. """ instance = cast(datetime, cls._mock_queue.next()) if tz is not None: if cls._mock_tzinfo: instance = instance - cls._mock_tzinfo.utcoffset(instance) instance = tz.fromutc(instance.replace(tzinfo=tz)) return cls._correct_mock_type(instance) @classmethod def utcnow(cls) -> datetime: """ This will return the next supplied or calculated datetime from the internal queue, rather than the actual current UTC datetime. If you care about timezones, see :ref:`timezones`. """ instance = cast(datetime, cls._mock_queue.next()) if cls._mock_tzinfo is not None: instance = instance - cls._mock_tzinfo.utcoffset(instance) return instance def date(self) -> date: """ This will return the date component of the current mock instance, but using the date type supplied when the mock class was created. """ return self._mock_date_type( self.year, self.month, self.day ) @overload def mock_datetime( tzinfo: TZInfo = None, delta: float = None, delta_type: str = 'seconds', date_type: Type[date] = date, strict: bool = False ) -> Type[MockDateTime]: ... @overload def mock_datetime( year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: TZInfo = None, delta: float = None, delta_type: str = 'seconds', date_type: Type[date] = date, strict: bool = False ) -> Type[MockDateTime]: ... @overload def mock_datetime( default: datetime, tzinfo: TZInfo = None, delta: float = None, delta_type: str = 'seconds', date_type: Type[date] = date, strict: bool = False ) -> Type[MockDateTime]: ... @overload def mock_datetime( default: None, # explicit None positional tzinfo: TZInfo = None, delta: float = None, delta_type: str = 'seconds', date_type: Type[date] = date, strict: bool = False ) -> Type[MockDateTime]: ... def mock_datetime( *args, tzinfo: TZInfo = None, delta: float = None, delta_type: str = 'seconds', date_type: Type[date] = date, strict: bool = False, **kw, ) -> Type[MockDateTime]: """ .. currentmodule:: testfixtures.datetime A function that returns a mock object that can be used in place of the :class:`datetime.datetime` class but where the return value of :meth:`~MockDateTime.now` can be controlled. If a single positional argument of ``None`` is passed, then the queue of datetimes to be returned will be empty and you will need to call :meth:`~MockDateTime.set` or :meth:`~MockDateTime.add` before calling :meth:`~MockDateTime.now` or :meth:`~MockDateTime.utcnow`. If an instance of :class:`~datetime.datetime` is passed as a single positional argument, that will be used as the first date returned by :meth:`~MockDateTime.now` :param year: An optional year used to create the first datetime returned by :meth:`~MockDateTime.now`. :param month: An optional month used to create the first datetime returned by :meth:`~MockDateTime.now`. :param day: An optional day used to create the first datetime returned by :meth:`~MockDateTime.now`. :param hour: An optional hour used to create the first datetime returned by :meth:`~MockDateTime.now`. :param minute: An optional minute used to create the first datetime returned by :meth:`~MockDateTime.now`. :param second: An optional second used to create the first datetime returned by :meth:`~MockDateTime.now`. :param microsecond: An optional microsecond used to create the first datetime returned by :meth:`~MockDateTime.now`. :param tzinfo: An optional :class:`datetime.tzinfo`, see :ref:`timezones`. :param delta: The size of the delta to use between values returned from mocked class methods. If not specified, it will increase by 1 with each call to :meth:`~MockDateTime.now`. :param delta_type: The type of the delta to use between values returned from mocked class methods. This can be any keyword parameter accepted by the :class:`~datetime.timedelta` constructor. :param date_type: The type to use for the return value of the mocked class methods. This can help with gotchas that occur when type checking is performed on values returned by the :meth:`~testfixtures.datetime.MockDateTime.date` method. :param strict: If ``True``, calling the mock class and any of its methods will result in an instance of the mock being returned. If ``False``, the default, an instance of :class:`~datetime.datetime` will be returned instead. The mock returned will behave exactly as the :class:`datetime.datetime` class as well as being a subclass of :class:`~testfixtures.datetime.MockDateTime`. """ if len(args) > 7: tzinfo = args[7] args = args[:7] else: tzinfo = tzinfo or (getattr(args[0], 'tzinfo', None) if args else None) return cast(Type[MockDateTime], mock_factory( 'MockDateTime', MockDateTime, (2001, 1, 1, 0, 0, 0), args, kw, tzinfo=tzinfo, delta=delta, delta_delta=10, delta_type=delta_type, date_type=date_type, strict=strict, )) class MockDate(MockedCurrent, date): @classmethod def _correct_mock_type(cls, instance): return cls._mock_class( instance.year, instance.month, instance.day, ) @overload @classmethod def add( cls, year: int, month: int, day: int, ) -> None: ... @overload @classmethod def add( cls, instance: date, ) -> None: ... @classmethod def add(cls, *args, **kw): """ This will add the :class:`datetime.date` created from the supplied parameters to the queue of dates to be returned by :meth:`~MockDate.today`. An instance of :class:`~datetime.date` may also be passed as a single positional argument. """ return super().add(*args, **kw) @overload @classmethod def set( cls, year: int, month: int, day: int, ) -> None: ... @overload @classmethod def set( cls, instance: date, ) -> None: ... @classmethod def set(cls, *args, **kw) -> None: """ This will set the :class:`datetime.date` created from the supplied parameters as the next date to be returned by :meth:`~MockDate.today`, regardless of any dates in the queue. An instance of :class:`~datetime.date` may also be passed as a single positional argument. """ return super().set(*args, **kw) @overload @classmethod def tick( cls, days: float = ..., weeks: float = ..., ) -> None: ... @overload @classmethod def tick( cls, delta: timedelta, # can become positional-only when Python 3.8 minimum ) -> None: ... @classmethod def tick(cls, *args, **kw) -> None: """ This method should be called either with a :class:`~datetime.timedelta` as a positional argument, or with keyword parameters that will be used to construct a :class:`~datetime.timedelta`. The :class:`~datetime.timedelta` will be used to advance the next date to be returned by :meth:`~MockDate.today`. """ return super().tick(*args, **kw) @classmethod def today(cls) -> date: """ This will return the next supplied or calculated date from the internal queue, rather than the actual current date. """ return cast(date, cls._mock_queue.next()) @overload def mock_date( delta: float = None, delta_type: str = None, date_type: Type[date] = date, strict: bool = False ) -> Type[MockDate]: ... @overload def mock_date( year: int, month: int, day: int, delta: float = None, delta_type: str = 'days', strict: bool = False, ) -> Type[MockDate]: ... @overload def mock_date( default: date, delta: float = None, delta_type: str = 'days', strict: bool = False, ) -> Type[MockDate]: ... @overload def mock_date( default: None, # explicit None positional delta: float = None, delta_type: str = 'days', strict: bool = False, ) -> Type[MockDate]: ... def mock_date( *args, delta: float = None, delta_type: str = 'days', strict: bool = False, **kw ) -> Type[MockDate]: """ .. currentmodule:: testfixtures.datetime A function that returns a mock object that can be used in place of the :class:`datetime.date` class but where the return value of :meth:`~datetime.date.today` can be controlled. If a single positional argument of ``None`` is passed, then the queue of dates to be returned will be empty and you will need to call :meth:`~MockDate.set` or :meth:`~MockDate.add` before calling :meth:`~MockDate.today`. If an instance of :class:`~datetime.date` is passed as a single positional argument, that will be used as the first date returned by :meth:`~datetime.date.today` :param year: An optional year used to create the first date returned by :meth:`~datetime.date.today`. :param month: An optional month used to create the first date returned by :meth:`~datetime.date.today`. :param day: An optional day used to create the first date returned by :meth:`~datetime.date.today`. :param delta: The size of the delta to use between values returned from :meth:`~datetime.date.today`. If not specified, it will increase by 1 with each call to :meth:`~datetime.date.today`. :param delta_type: The type of the delta to use between values returned from :meth:`~datetime.date.today`. This can be any keyword parameter accepted by the :class:`~datetime.timedelta` constructor. :param strict: If ``True``, calling the mock class and any of its methods will result in an instance of the mock being returned. If ``False``, the default, an instance of :class:`~datetime.date` will be returned instead. The mock returned will behave exactly as the :class:`datetime.date` class as well as being a subclass of :class:`~testfixtures.datetime.MockDate`. """ return cast(Type[MockDate], mock_factory( 'MockDate', MockDate, (2001, 1, 1), args, kw, delta=delta, delta_type=delta_type, strict=strict, )) ms = 10**6 class MockTime(MockedCurrent, datetime): @overload @classmethod def add( cls, year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., ) -> None: ... @overload @classmethod def add( cls, instance: datetime, ) -> None: ... @classmethod def add(cls, *args, **kw): """ This will add the time specified by the supplied parameters to the queue of times to be returned by calls to the mock. The parameters are the same as the :class:`datetime.datetime` constructor. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ return super().add(*args, **kw) @overload @classmethod def set( cls, year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., ) -> None: ... @overload @classmethod def set( cls, instance: datetime, ) -> None: ... @classmethod def set(cls, *args, **kw): """ This will set the time specified by the supplied parameters as the next time to be returned by a call to the mock, regardless of any times in the queue. The parameters are the same as the :class:`datetime.datetime` constructor. An instance of :class:`~datetime.datetime` may also be passed as a single positional argument. """ return super().set(*args, **kw) @overload @classmethod def tick( cls, days: float = ..., seconds: float = ..., microseconds: float = ..., milliseconds: float = ..., minutes: float = ..., hours: float = ..., weeks: float = ..., ) -> None: ... @overload @classmethod def tick( cls, delta: timedelta, # can become positional-only when Python 3.8 minimum ) -> None: ... @classmethod def tick(cls, *args, **kw): """ This method should be called either with a :class:`~datetime.timedelta` as a positional argument, or with keyword parameters that will be used to construct a :class:`~datetime.timedelta`. The :class:`~datetime.timedelta` will be used to advance the next time to be returned by a call to the mock. """ return super().tick(*args, **kw) def __new__(cls, *args, **kw) -> float: """ Return a :class:`float` representing the mocked current time as would normally be returned by :func:`time.time`. """ if args or kw: # Used when adding stuff to the queue return super().__new__(cls, *args, **kw) else: instance = cast(datetime, cls._mock_queue.next()) time = timegm(instance.utctimetuple()) time += (float(instance.microsecond)/ms) return time @overload def mock_time( delta: float = None, delta_type: str = 'seconds', ) -> Type[MockDateTime]: ... @overload def mock_time( year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., delta: float = None, delta_type: str = 'seconds', ) -> Type[MockDateTime]: ... @overload def mock_time( default: datetime, delta: float = None, delta_type: str = 'seconds', ) -> Type[MockDateTime]: ... @overload def mock_time( default: None, # explicit None positional delta: float = None, delta_type: str = 'seconds', ) -> Type[MockDateTime]: ... def mock_time(*args, delta: float = None, delta_type: str = 'seconds', **kw) -> Type[MockTime]: """ .. currentmodule:: testfixtures.datetime A function that returns a :class:`mock object <testfixtures.datetime.MockTime>` that can be used in place of the :func:`time.time` function but where the return value can be controlled. If a single positional argument of ``None`` is passed, then the queue of times to be returned will be empty and you will need to call :meth:`~MockTime.set` or :meth:`~MockTime.add` before calling the mock. If an instance of :class:`~datetime.datetime` is passed as a single positional argument, that will be used to create the first time returned. :param year: An optional year used to create the first time returned. :param month: An optional month used to create the first time. :param day: An optional day used to create the first time. :param hour: An optional hour used to create the first time. :param minute: An optional minute used to create the first time. :param second: An optional second used to create the first time. :param microsecond: An optional microsecond used to create the first time. :param delta: The size of the delta to use between values returned. If not specified, it will increase by 1 with each call to the mock. :param delta_type: The type of the delta to use between values returned. This can be any keyword parameter accepted by the :class:`~datetime.timedelta` constructor. The :meth:`~testfixtures.datetime.MockTime.add`, :meth:`~testfixtures.datetime.MockTime.set` and :meth:`~testfixtures.datetime.MockTime.tick` methods on the mock can be used to control the return values. """ if 'tzinfo' in kw or len(args) > 7 or (args and getattr(args[0], 'tzinfo', None)): raise TypeError("You don't want to use tzinfo with test_time") return cast(Type[MockTime], mock_factory( 'MockTime', MockTime, (2001, 1, 1, 0, 0, 0), args, kw, delta=delta, delta_type=delta_type, ))
© 2024 UnknownSec