Mercurial > repos > shellac > guppy_basecaller

comparison env/lib/python3.7/site-packages/mypy_extensions.py @ 5:9b1c78e6ba9c draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload commit 6c0a8142489327ece472c84e558c47da711a9142"
author shellac
date Mon, 01 Jun 2020 08:59:25 -0400
parents 79f47841a781
children
comparison
equal deleted inserted replaced
4:79f47841a781 5:9b1c78e6ba9c
1 """Defines experimental extensions to the standard "typing" module that are
2 supported by the mypy typechecker.
3
4 Example usage:
5 from mypy_extensions import TypedDict
6 """
7
8 from typing import Any
9
10 # NOTE: This module must support Python 2.7 in addition to Python 3.x
11
12 import sys
13 # _type_check is NOT a part of public typing API, it is used here only to mimic
14 # the (convenient) behavior of types provided by typing module.
15 from typing import _type_check # type: ignore
16
17
18 def _check_fails(cls, other):
19 try:
20 if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools', 'typing']:
21 # Typed dicts are only for static structural subtyping.
22 raise TypeError('TypedDict does not support instance and class checks')
23 except (AttributeError, ValueError):
24 pass
25 return False
26
27
28 def _dict_new(cls, *args, **kwargs):
29 return dict(*args, **kwargs)
30
31
32 def _typeddict_new(cls, _typename, _fields=None, **kwargs):
33 total = kwargs.pop('total', True)
34 if _fields is None:
35 _fields = kwargs
36 elif kwargs:
37 raise TypeError("TypedDict takes either a dict or keyword arguments,"
38 " but not both")
39
40 ns = {'__annotations__': dict(_fields), '__total__': total}
41 try:
42 # Setting correct module is necessary to make typed dict classes pickleable.
43 ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
44 except (AttributeError, ValueError):
45 pass
46
47 return _TypedDictMeta(_typename, (), ns)
48
49
50 class _TypedDictMeta(type):
51 def __new__(cls, name, bases, ns, total=True):
52 # Create new typed dict class object.
53 # This method is called directly when TypedDict is subclassed,
54 # or via _typeddict_new when TypedDict is instantiated. This way
55 # TypedDict supports all three syntaxes described in its docstring.
56 # Subclasses and instances of TypedDict return actual dictionaries
57 # via _dict_new.
58 ns['__new__'] = _typeddict_new if name == 'TypedDict' else _dict_new
59 tp_dict = super(_TypedDictMeta, cls).__new__(cls, name, (dict,), ns)
60
61 anns = ns.get('__annotations__', {})
62 msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
63 anns = {n: _type_check(tp, msg) for n, tp in anns.items()}
64 for base in bases:
65 anns.update(base.__dict__.get('__annotations__', {}))
66 tp_dict.__annotations__ = anns
67 if not hasattr(tp_dict, '__total__'):
68 tp_dict.__total__ = total
69 return tp_dict
70
71 __instancecheck__ = __subclasscheck__ = _check_fails
72
73
74 TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
75 TypedDict.__module__ = __name__
76 TypedDict.__doc__ = \
77 """A simple typed name space. At runtime it is equivalent to a plain dict.
78
79 TypedDict creates a dictionary type that expects all of its
80 instances to have a certain set of keys, with each key
81 associated with a value of a consistent type. This expectation
82 is not checked at runtime but is only enforced by typecheckers.
83 Usage::
84
85 Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
86 a: Point2D = {'x': 1, 'y': 2, 'label': 'good'} # OK
87 b: Point2D = {'z': 3, 'label': 'bad'} # Fails type check
88 assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
89
90 The type info could be accessed via Point2D.__annotations__. TypedDict
91 supports two additional equivalent forms::
92
93 Point2D = TypedDict('Point2D', x=int, y=int, label=str)
94
95 class Point2D(TypedDict):
96 x: int
97 y: int
98 label: str
99
100 The latter syntax is only supported in Python 3.6+, while two other
101 syntax forms work for Python 2.7 and 3.2+
102 """
103
104 # Argument constructors for making more-detailed Callables. These all just
105 # return their type argument, to make them complete noops in terms of the
106 # `typing` module.
107
108
109 def Arg(type=Any, name=None):
110 """A normal positional argument"""
111 return type
112
113
114 def DefaultArg(type=Any, name=None):
115 """A positional argument with a default value"""
116 return type
117
118
119 def NamedArg(type=Any, name=None):
120 """A keyword-only argument"""
121 return type
122
123
124 def DefaultNamedArg(type=Any, name=None):
125 """A keyword-only argument with a default value"""
126 return type
127
128
129 def VarArg(type=Any):
130 """A *args-style variadic positional argument"""
131 return type
132
133
134 def KwArg(type=Any):
135 """A **kwargs-style variadic keyword argument"""
136 return type
137
138
139 # Return type that indicates a function does not return
140 class NoReturn: pass
141
142
143 def trait(cls):
144 return cls
145
146
147 def mypyc_attr(*attrs, **kwattrs):
148 return lambda x: x
149
150
151 # TODO: We may want to try to properly apply this to any type
152 # variables left over...
153 class _FlexibleAliasClsApplied:
154 def __init__(self, val):
155 self.val = val
156
157 def __getitem__(self, args):
158 return self.val
159
160
161 class _FlexibleAliasCls:
162 def __getitem__(self, args):
163 return _FlexibleAliasClsApplied(args[-1])
164
165
166 FlexibleAlias = _FlexibleAliasCls()