Skip to content

typecheck

on_manifold(func)

Checks That the provided Cochain is defined on a SimplicialManifold.

Notes
  • This is a decorator...
Source code in src/dxtr/utils/typecheck.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
def on_manifold(func) -> Optional[Any]:
    """Checks That the provided `Cochain` is defined on a `SimplicialManifold`.

    Notes
    -----
      * This is a decorator...
    """
    @wraps(func)        
    def wrapper(*args, **kwargs):
        try:
            from dxtr import Cochain, SimplicialManifold
            assert isinstance(args[0], Cochain), (
                    'Only `Cochain` accepted as input.')
            assert isinstance(args[0].complex, SimplicialManifold), (
            'The input `Cochain` must be defined on a `SimplicialManifold.`')

            result = func(*args, **kwargs)

        except AssertionError as msg:
            from dxtr import logger
            logger.warning(msg)
            return None

        return result
    return wrapper

typecheck(expected_types, arg_idx=0)

Checks if the arg_idx-th provided argument has the proper type.

Source code in src/dxtr/utils/typecheck.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def typecheck(expected_types, arg_idx:int=0) -> Optional[Any]:
    """Checks if the arg_idx-th provided argument has the proper type.
    """
    if isinstance(expected_types, Iterable):
        expected_types = tuple(expected_types)
    else:
        expected_types = (expected_types,)

    type_names = [xpct_type.__name__ for xpct_type in expected_types]
    def decorator(func):
        @wraps(func)        
        def wrapper(*args, **kwargs):
            try:
                assert isinstance(args[arg_idx], expected_types), (
        f'Only {type_names} accepted as input for {func.__name__}.')
                result = func(*args, **kwargs)

            except AssertionError as msg:
                from dxtr import logger
                logger.warning(msg)
                return None

            return result
        return wrapper
    return decorator

valid_input(func)

Checks that the provided object matches the saving criteria.

Notes
  • This is a decorator useful for recording objects on disk.
  • Saving criteria:
    • Instance of SimplicialManifold or Cochain.
    • 2D complex or manifold as underlying structure.
Source code in src/dxtr/utils/typecheck.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
def valid_input(func) -> Optional[Any]:
    """Checks that the provided object matches the saving criteria.

    Notes
    -----
      * This is a decorator useful for recording objects on disk.
      * Saving criteria:
        * Instance of `SimplicialManifold` or `Cochain`.
        * 2D complex or manifold as underlying structure.
    """
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            from dxtr import Cochain, SimplicialComplex
            EXPECTED_TYPES = (SimplicialComplex, Cochain)

            assert isinstance(args[0], EXPECTED_TYPES), (
                f'{type(args[0])} not supporting for saving.')

            if isinstance(args[0], SimplicialComplex):
                obj = args[0]
            elif isinstance(args[0], Cochain):
                obj = args[0].complex

            n = obj.dim
            assert n == 2, f'{n}D supporting complexes not supported, only 2D.'
            return func(*args, **kwargs)

        except AssertionError as msg:
            from dxtr import logger
            logger.warning(msg)
            return None
    return wrapper