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
📁 ..	-	2025-05-25 12:26
📄 __init__.py	0 B	2025-05-25 12:26
📁 __pycache__	-	2025-05-25 12:26
📄 test_common_ancestor.py from typing import Type from unittest import TestCase from typish import common_ancestor, common_ancestor_of_types, NoneType class A: pass class B(A): pass class C(B): pass class D(C): pass class E(D): pass class TestCommonAncestor(TestCase): def test_common_ancestor(self): self.assertEqual(C, common_ancestor(E(), C(), D(), E())) self.assertEqual(B, common_ancestor(E(), C(), D(), E(), B())) self.assertEqual(object, common_ancestor(E(), C(), D(), E(), B(), 42)) def test_common_ancestor_of_types(self): self.assertEqual(C, common_ancestor_of_types(E, C, D, E)) self.assertEqual(object, common_ancestor_of_types(int, str)) common_ancestor_of_types(list, tuple) def test_common_ancestor_of_typing_types(self): self.assertEqual(type, common_ancestor_of_types(Type[int], Type[str])) def test_common_acestor_of_collections(self): self.assertEqual(list, common_ancestor([1, 2, 3], ['a', 'b', 'c'])) def test_special_args(self): self.assertEqual(NoneType, common_ancestor(None, None)) self.assertEqual(int, common_ancestor(42)) def test_invalid(self): with self.assertRaises(TypeError): common_ancestor()	1.24 KB	2025-05-25 12:26
📄 test_get_args_and_return_type.py from typing import Callable from unittest import TestCase from typish import NoneType, get_args_and_return_type class TestGetArgsAndReturnType(TestCase): def test_get_args_and_return_type(self): arg_types, return_type = get_args_and_return_type( Callable[[int, str], float]) self.assertEqual((int, str), arg_types) self.assertEqual(float, return_type) def test_get_args_and_return_type_no_args(self): arg_types, return_type = get_args_and_return_type( Callable[[], float]) self.assertEqual(tuple(), arg_types) self.assertEqual(float, return_type) def test_get_args_and_return_type_no_return_type(self): arg_types, return_type = get_args_and_return_type( Callable[[int, str], None]) self.assertEqual((int, str), arg_types) self.assertEqual(NoneType, return_type) def test_get_args_and_return_type_no_hints(self): arg_types1, return_type1 = get_args_and_return_type(Callable) arg_types2, return_type2 = get_args_and_return_type(callable) self.assertEqual(None, arg_types1) self.assertEqual(None, return_type1) self.assertEqual(None, arg_types2) self.assertEqual(None, return_type2)	1.26 KB	2025-05-25 12:26
📄 test_get_mro.py import typing from typing import Union from unittest import TestCase from typish import get_mro class A: ... class B(A): ... class TestGetMRO(TestCase): def test_get_mro(self): mro_b = get_mro(B) self.assertTupleEqual((B, A, object), mro_b) def test_get_mro_union(self): mro_u = get_mro(Union[int, str]) # Below is to stay compatible with Python 3.5+ super_cls = getattr(typing, '_GenericAlias', getattr(typing, 'GenericMeta', None)) expected = (typing.Union, super_cls, object) self.assertTupleEqual(expected, mro_u) def test_get_mro_object(self): mro_b = get_mro(B()) self.assertTupleEqual((B, A, object), mro_b)	779 B	2025-05-25 12:26
📄 test_get_type.py from typing import Dict, Set, List, Tuple, Type, Callable, Any, Awaitable, Union from unittest import TestCase import numpy from typish import get_type, instance_of, NoneType, Unknown class TestGetType(TestCase): def test_get_type_list(self): self.assertEqual(List[int], get_type([1, 2, 3])) self.assertEqual(List[object], get_type([1, 2, '3'])) self.assertEqual(List[Unknown], get_type([])) def test_get_type_list_with_union(self): self.assertEqual(List[Union[int, str, float]], get_type([1, '2', 3.0], True)) def test_get_type_set(self): self.assertEqual(Set[int], get_type({1, 2, 3})) self.assertEqual(Set[object], get_type({1, 2, '3'})) self.assertEqual(Set[Unknown], get_type(set([]))) def test_get_type_dict(self): self.assertEqual(Dict[str, int], get_type({'a': 1, 'b': 2})) self.assertEqual(Dict[int, object], get_type({1: 'a', 2: 2})) self.assertEqual(Dict[Unknown, Unknown], get_type({})) def test_get_type_tuple(self): self.assertEqual(Tuple[int, int, int], get_type((1, 2, 3))) self.assertEqual(Tuple[int, str, str], get_type((1, '2', '3'))) def test_get_type_callable(self): def func1(x: int, y: str) -> object: pass def func2() -> int: pass def func3(x: int): pass def func4(): pass def func5(x): pass def func6(l: List[List[List[int]]]): pass self.assertEqual(Callable[[int, str], object], get_type((func1))) self.assertEqual(Callable[[], int], get_type(func2)) self.assertEqual(Callable[[int], NoneType], get_type(func3)) self.assertEqual(Callable, get_type(func4)) self.assertEqual(Callable[[Any], NoneType], get_type(func5)) self.assertEqual(Callable[[List[List[List[int]]]], NoneType], get_type(func6)) def test_get_type_async(self): async def func(x: int) -> str: return '42' self.assertEqual(Callable[[int], Awaitable[str]], get_type(func)) def test_get_type_lambda(self): self.assertEqual(Callable[[Unknown, Unknown], Unknown], get_type(lambda x, y: 42)) self.assertEqual(Callable[[], Unknown], get_type(lambda: 42)) def test_get_type_deep(self): self.assertEqual(List[List[int]], get_type([[1, 2], [3]])) self.assertEqual(List[List[object]], get_type([[1, 2], ['3']])) deep = [[[1, 2]], [[3]], [[4], [5, '6']]] self.assertEqual(List[List[List[object]]], get_type(deep)) self.assertEqual(Dict[str, List[List[List[object]]]], get_type({'a': deep})) def test_get_type_type(self): self.assertEqual(Type[int], get_type(int)) def test_get_type_some_class(self): class SomeRandomClass: pass self.assertEqual(SomeRandomClass, get_type(SomeRandomClass())) def test_get_type_any(self): any_type = get_type(Any) self.assertEqual(Any, any_type) def test_get_type_union(self): union_type = get_type(Union[int, str]) # The following line should not raise. Union[(union_type,)] self.assertTrue(instance_of(Union[int, str], union_type)) def test_get_type_of_ndarray(self): arr_type = get_type(numpy.array([1, 2, 3])) self.assertEqual(numpy.ndarray, arr_type)	3.42 KB	2025-05-25 12:26
📄 test_get_type_hints_of_callable.py from typing import Callable from unittest import TestCase from typish import get_type_hints_of_callable, get_args_and_return_type class TestGetTypeHintsOfCallable(TestCase): def test_get_type_hints_of_callable(self): def func(x: int, y: int) -> str: return '{}{}'.format(x, y) hints = get_type_hints_of_callable(func) self.assertEqual(int, hints['x']) self.assertEqual(int, hints['y']) self.assertEqual(str, hints['return']) def test_get_type_hints_of_empty_callable(self): def func(): return 42 hints = get_type_hints_of_callable(func) self.assertEqual({}, hints) def test_get_args_and_return_type(self): args, return_type = get_args_and_return_type(Callable[[int, int], str]) self.assertTupleEqual((int, int), args) self.assertEqual(str, return_type) def test_get_args_and_return_type_with_explicit_result(self): class CallableMock: __args__ = (int, int) __result__ = str args, return_type = get_args_and_return_type(CallableMock) self.assertTupleEqual((int, int), args) self.assertEqual(str, return_type) def test_get_type_hints_of_callable_with_raising_callable(self): # Python3.5: get_type_hints raises on classes without explicit constructor class CallableMetaMock(type): def __getattribute__(self, item): raise AttributeError('') class CallableMock(metaclass=CallableMetaMock): ... self.assertEqual({}, get_type_hints_of_callable(CallableMock))	1.64 KB	2025-05-25 12:26
📄 test_instance_of.py from sys import version_info from typing import List, Dict, Union, Optional, Callable, Any, Tuple, Type, Iterable from unittest import TestCase, skipUnless import nptyping as nptyping import numpy from typish import Literal, instance_of, State, register_get_type class A: pass class B(A): pass class C(B): pass class D(C): pass class E(D): pass class F(E, str): pass class TestInstanceOf(TestCase): def test_instance_of(self): self.assertTrue(instance_of([[[1], [2]]], List[List[List[int]]])) self.assertTrue(instance_of([[[1], ['2']]], List[List[List[object]]])) self.assertTrue(instance_of([], List[int])) self.assertTrue(instance_of({}, Dict[int, int])) def test_instance_of_multiple(self): self.assertTrue(instance_of(F(), A)) self.assertTrue(instance_of(F(), str)) self.assertTrue(instance_of(F(), A, str)) self.assertTrue(not instance_of(F(), A, str, int)) def test_instance_of_union(self): self.assertTrue(instance_of(F(), Union[int, A])) self.assertTrue(instance_of(F(), Union[A, int])) self.assertTrue(instance_of(F(), Union[A, str])) self.assertTrue(instance_of(F(), Optional[str])) self.assertTrue(instance_of(None, Optional[str])) self.assertTrue(instance_of(Any, Union[int, Literal[Any]])) def test_instance_of_callable(self): def func1(x: int, y: str) -> object: pass def func2() -> int: pass def func3(x: int): pass def func4(): pass def func5(x): pass def func6(l: List[List[List[int]]]): pass self.assertTrue(instance_of(func1, Callable[[int, str], object])) self.assertTrue(instance_of(func1, Callable[[object, str], object])) self.assertTrue(not instance_of(func1, Callable[[str, str], object])) self.assertTrue(not instance_of(func1, Callable[[str, str], int])) self.assertTrue(instance_of(func2, Callable[[], int])) self.assertTrue(instance_of(func3, Callable[[int], Any])) self.assertTrue(instance_of(func4, Callable)) self.assertTrue(instance_of(func5, Callable[[Any], Any])) self.assertTrue(instance_of(func6, Callable[[List[List[List[int]]]], Any])) def test_lambda_instance_of_callable(self): self.assertTrue(instance_of(lambda x, y: 42, Callable[[int, str], str])) self.assertTrue(instance_of(lambda: 42, Callable[[], str])) def test_instance_of_type(self): self.assertTrue(instance_of(int, Type)) self.assertTrue(instance_of(int, Type[int])) self.assertTrue(not instance_of(str, Type[int])) def test_instance_of_tuple(self): self.assertTrue(instance_of((1,), Tuple[int])) self.assertTrue(instance_of((1, 2, 3), Tuple[int, ...])) def test_instance_of_list_with_union(self): self.assertTrue(instance_of([1, '2', 3], List[Union[int, str]])) self.assertTrue(not instance_of([1, '2', 3], List[Union[int, float]])) def test_instance_of_tuple_with_union(self): self.assertTrue(instance_of((1, '2', 3), Tuple[Union[int, str], ...])) self.assertTrue(not instance_of((1, '2', 3), Tuple[Union[int, float], ...])) def test_instance_of_iterable(self): self.assertTrue(instance_of([1, 2, 3], Iterable[int])) self.assertTrue(instance_of((1, 2, 3), Iterable[int])) def test_instance_of_literal(self): self.assertTrue(instance_of(42, Literal[42])) self.assertTrue(instance_of(42, Literal[42], int)) self.assertTrue(not instance_of(43, Literal[42])) self.assertTrue(not instance_of(42, Literal[42], str)) self.assertTrue(not instance_of(42, Literal)) self.assertTrue(instance_of(Any, Literal[Any])) self.assertTrue(not instance_of(42, Literal[Any])) self.assertTrue(not instance_of(42, Literal)) self.assertTrue(instance_of(2, Literal[1, 2])) def test_instance_of_typing_literal(self): # This is to mock Python 3.8 Literal. class LiteralMockMeta(type): __name__ = 'Literal' def __instancecheck__(self, instance): raise Exception('typing.Literal does not allow instance checks.') class LiteralMock(metaclass=LiteralMockMeta): __args__ = (42,) self.assertTrue(instance_of(42, LiteralMock)) def test_instance_of_numpy(self): self.assertTrue(instance_of(numpy.array([1, 2, 3]), numpy.ndarray)) def test_instance_of_nptyping_ndarray(self): local_state = State() register_get_type(numpy.ndarray, nptyping.NDArray.type_of, local_state) arr = numpy.array([1, 2, 3]) arr_type = nptyping.NDArray[(3,), int] self.assertTrue(instance_of(arr, arr_type, state=local_state)) self.assertTrue(instance_of([arr], List[arr_type], state=local_state)) self.assertTrue(instance_of([arr], List[nptyping.NDArray], state=local_state)) self.assertTrue(not instance_of([arr], List[nptyping.NDArray[(4,), float]], state=local_state)) @skipUnless(10 * version_info.major + version_info.minor >= 39, 'PEP-585') def test_instance_of_py39_types(self): self.assertTrue(instance_of({'42': 42}, Dict[str, int])) self.assertTrue(not instance_of({'42': 42}, Dict[str, str])) self.assertTrue(not instance_of({42: 42}, Dict[str, int])) self.assertTrue(instance_of([1, 2, 3], list[int])) self.assertTrue(not instance_of([1, 2, 3], list[str]))	5.61 KB	2025-05-25 12:26
📄 test_is_optional_type.py from typing import Optional, Union from unittest import TestCase from typish import ( NoneType, ) from typish.functions._is_optional_type import is_optional_type class TestIsOptionalType(TestCase): def test_is_optional_type(self): self.assertTrue(is_optional_type(Optional[str])) self.assertTrue(is_optional_type(Union[str, None])) self.assertTrue(is_optional_type(Union[str, NoneType])) self.assertTrue(not is_optional_type(str)) self.assertTrue(not is_optional_type(Union[str, int]))	553 B	2025-05-25 12:26
📄 test_is_type_annotation.py from typing import List from unittest import TestCase from typish import ( is_type_annotation, T, KT, VT, Unknown, Module, NoneType, EllipsisType, Empty, ) class TestIsTypeAnnotation(TestCase): def test_is_type_annotation(self): # builtins and typing. self.assertTrue(is_type_annotation(int)) self.assertTrue(is_type_annotation(List)) # Typish types. self.assertTrue(is_type_annotation(Empty)) self.assertTrue(is_type_annotation(Unknown)) self.assertTrue(is_type_annotation(Module)) self.assertTrue(is_type_annotation(NoneType)) self.assertTrue(is_type_annotation(EllipsisType)) # No instances. self.assertTrue(not is_type_annotation(123)) self.assertTrue(not is_type_annotation('No way')) # Typevars do not count. self.assertTrue(not is_type_annotation(T)) self.assertTrue(not is_type_annotation(KT)) self.assertTrue(not is_type_annotation(VT))	1.03 KB	2025-05-25 12:26
📄 test_origin_and_alias.py from collections import deque, defaultdict from collections.abc import Set from typing import ( Dict, List, Tuple, FrozenSet, Deque, DefaultDict, Type, AbstractSet, Set as TypingSet ) from unittest import TestCase from typish import get_origin, get_alias class Union: """To shadow typing.Union.""" class MetaMock(type): __name__ = 'list' __args__ = (str,) class ListMock(metaclass=MetaMock): ... class TestOriginAndAlias(TestCase): def test_get_origin(self): self.assertEqual(list, get_origin(List[int])) self.assertEqual(tuple, get_origin(Tuple[int, ...])) self.assertEqual(dict, get_origin(Dict[str, int])) self.assertEqual(set, get_origin(TypingSet)) self.assertEqual(deque, get_origin(Deque)) self.assertEqual(defaultdict, get_origin(DefaultDict)) self.assertEqual(type, get_origin(Type[int])) self.assertEqual(Set, get_origin(AbstractSet)) self.assertIn('test_origin_and_alias', str(get_origin(Union))) try: self.assertEqual(dict, get_origin(dict[str, str])) self.assertEqual(list, get_origin(list[int])) except TypeError as err: ... # On <3.9 def test_get_alias(self): self.assertEqual(List, get_alias(list)) self.assertEqual(Tuple, get_alias(tuple)) self.assertEqual(Dict, get_alias(dict)) self.assertEqual(TypingSet, get_alias(set)) self.assertEqual(FrozenSet, get_alias(frozenset)) self.assertEqual(Deque, get_alias(deque)) self.assertEqual(DefaultDict, get_alias(defaultdict)) self.assertEqual(Type, get_alias(type)) self.assertEqual(AbstractSet, get_alias(Set)) self.assertEqual(List, get_alias(List)) self.assertEqual(Dict, get_alias(Dict)) def test_get_alias_from_parameterized_standard_list(self): self.assertEqual(List[str], get_alias(ListMock))	1.97 KB	2025-05-25 12:26
📄 test_subclass_of.py import sys from typing import List, Tuple, Union, Optional, Iterable, Any from unittest import TestCase from typish import Literal, subclass_of, Unknown, NoneType class A: pass class B(A): pass class C(B): pass class D(C): pass class E(D): pass class F(E, str): pass class TestSubclassOf(TestCase): def test_subclass_of(self): self.assertTrue(not subclass_of(int, str)) self.assertTrue(subclass_of(E, A)) self.assertTrue(subclass_of(str, object)) self.assertTrue(subclass_of(list, List)) self.assertTrue(subclass_of(List[int], List[int])) self.assertTrue(not subclass_of(List[int], List[str])) self.assertTrue(subclass_of(List[List[List[int]]], List[List[List[int]]])) self.assertTrue(subclass_of(List[int], List[object])) self.assertTrue(not subclass_of(List[object], List[int])) self.assertTrue(subclass_of(List[Unknown], List[int])) self.assertTrue(not subclass_of('test', str)) def test_subclass_of_tuple(self): self.assertTrue(subclass_of(Tuple[int, int], Tuple[int, ...])) self.assertTrue(subclass_of(Tuple[int, ...], Tuple[int, ...])) self.assertTrue(subclass_of(Tuple[int, int], Tuple[object, ...])) self.assertTrue(subclass_of(Tuple[int, ...], Tuple[object, ...])) self.assertTrue(subclass_of(Tuple[A, B], Tuple[A, ...])) self.assertTrue(subclass_of(Tuple[int, int], Tuple[int, int])) self.assertTrue(subclass_of(Tuple[int, int], Tuple[object, int])) self.assertTrue(not subclass_of(Tuple[int, int], Tuple[str, int])) self.assertTrue(not subclass_of(Tuple[int, int], Tuple[int, int, int])) self.assertTrue(not subclass_of(Tuple[int, int, int], Tuple[int, int])) self.assertTrue(not subclass_of(Tuple[int, str], Tuple[int, ...])) def test_list_subclass_of_tuple(self): self.assertTrue(not subclass_of(List[int], Tuple[int, ...])) self.assertTrue(not subclass_of(List[int], Tuple[int, int])) def test_tuple_subclass_of_list(self): self.assertTrue(not subclass_of(Tuple[int, ...], List[int])) def test_subclass_of_iterable(self): self.assertTrue(subclass_of(List[int], Iterable[int])) self.assertTrue(subclass_of(Tuple[int, int, int], Iterable[int])) self.assertTrue(subclass_of(Tuple[int, ...], Iterable[int])) self.assertTrue(subclass_of(Tuple[B, C, D], Iterable[B])) self.assertTrue(subclass_of(Tuple[B, C, D], Iterable[A])) self.assertTrue(subclass_of(List[Tuple[int, str]], Iterable[Tuple[int, str]])) self.assertTrue(subclass_of(Tuple[Tuple[int, str]], Iterable[Tuple[int, str]])) def test_subclass_of_multiple(self): self.assertTrue(subclass_of(F, A)) self.assertTrue(subclass_of(F, str)) self.assertTrue(subclass_of(F, A, str)) self.assertTrue(not subclass_of(F, A, str, int)) def test_subclass_of_union(self): self.assertTrue(subclass_of(F, Union[int, str])) self.assertTrue(subclass_of(F, Union[A, int])) self.assertTrue(subclass_of(F, Union[A, B])) self.assertTrue(not subclass_of(int, Union[A, B])) self.assertTrue(subclass_of(F, Optional[A])) self.assertTrue(subclass_of(NoneType, Optional[A])) def test_union_subclass_of_union(self): # Subclass holds if all elements of the first enum subclass any of # the right enum. self.assertTrue(subclass_of(Union[C, D], Union[A, B])) # int is no subclass of any of Union[A, B]. self.assertTrue(not subclass_of(Union[C, D, int], Union[A, B])) def test_union_subclass_of(self): if sys.version_info[1] in (5,): self.assertTrue(not subclass_of(Union[int, A, B, F], Union[C, D])) else: self.assertTrue(subclass_of(Union[B, F], A)) self.assertTrue(not subclass_of(Union[A, B], C)) self.assertTrue(not subclass_of(Union[A, B], Union[C, D])) def test_subclass_of_literal(self): self.assertTrue(subclass_of(int, Literal[int])) self.assertTrue(subclass_of(Any, Literal[Any])) self.assertTrue(not subclass_of(int, Literal[Any])) self.assertTrue(not subclass_of(int, Literal))	4.24 KB	2025-05-25 12:26

Terminal