columnflow.types

columnflow.types#

Custom type definitions and shorthands to simplify imports of types that are spread across multiple packages.

class KeysView(mapping)#

Bases: MappingView, Set

class ValuesView(mapping)#

Bases: MappingView, Collection

ModuleType#

alias of ModuleType

GeneratorType#

alias of GeneratorType

class GenericAlias#

Bases: object

Represent a PEP 585 generic type

E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).

class TypeVar(name, *constraints, bound=None, covariant=False, contravariant=False)[source]#

Bases: _Final, _Immutable

Type variable.

Usage:

T = TypeVar('T')  # Can be anything
A = TypeVar('A', str, bytes)  # Must be str or bytes

Type variables exist primarily for the benefit of static type checkers. They serve as the parameters for generic types as well as for generic function definitions. See class Generic for more information on generic types. Generic functions work as follows:

def repeat(x: T, n: int) -> List[T]:

‘’’Return a list containing n references to x.’’’ return [x]*n

def longest(x: A, y: A) -> A:

‘’’Return the longest of two strings.’’’ return x if len(x) >= len(y) else y

The latter example’s signature is essentially the overloading of (str, str) -> str and (bytes, bytes) -> bytes. Also note that if the arguments are instances of some subclass of str, the return type is still plain str.

At runtime, isinstance(x, T) and issubclass(C, T) will raise TypeError.

Type variables defined with covariant=True or contravariant=True can be used to declare covariant or contravariant generic types. See PEP 484 for more details. By default generic types are invariant in all type variables.

Type variables can be introspected. e.g.:

T.__name__ == ‘T’ T.__constraints__ == () T.__covariant__ == False T.__contravariant__ = False A.__constraints__ == (str, bytes)

Note that only type variables defined in global scope can be pickled.

class TextIO[source]#

Bases: IO[str]

Typed version of the return of open() in text mode.

abstract property buffer: BinaryIO#
abstract property encoding: str#
abstract property errors: str | None#
abstract property line_buffering: bool#
abstract property newlines: Any#
class Annotated(*args, **kwargs)[source]#

Bases: object

Add context specific metadata to a type.

Example: Annotated[int, runtime_check.Unsigned] indicates to the hypothetical runtime_check module that this type is an unsigned int. Every other consumer of this type can ignore this metadata and treat this type as int.

The first argument to Annotated must be a valid type.

Details:

  • It’s an error to call Annotated with less than two arguments.

  • Nested Annotated are flattened:

    Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]

  • Instantiating an annotated type is equivalent to instantiating the

underlying type:

Annotated[C, Ann1](5) == C(5)

  • Annotated can be used as a generic type alias:

    Optimized = Annotated[T, runtime.Optimize()]
Optimized[int] == Annotated[int, runtime.Optimize()]

OptimizedList = Annotated[List[T], runtime.Optimize()]
OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
AnnotatedType#

alias of _AnnotatedAlias

class T#

Generic type variable, more stringent than Any.

alias of TypeVar(‘T’)

Contents