diff options
Diffstat (limited to 'sources/pyside2/PySide2/support/signature/layout.py')
| -rw-r--r-- | sources/pyside2/PySide2/support/signature/layout.py | 205 |
1 files changed, 1 insertions, 204 deletions
diff --git a/sources/pyside2/PySide2/support/signature/layout.py b/sources/pyside2/PySide2/support/signature/layout.py index e18cb2172..c8a4062cb 100644 --- a/sources/pyside2/PySide2/support/signature/layout.py +++ b/sources/pyside2/PySide2/support/signature/layout.py @@ -39,207 +39,4 @@ from __future__ import print_function, absolute_import -""" -layout.py - -The signature module now has the capability to configure -differently formatted versions of signatures. The default -layout is known from the "__signature__" attribute. - -The function "get_signature(ob, modifier=None)" produces the same -signatures by default. By passing different modifiers, you -can select different layouts. - -This module configures the different layouts which can be used. -It also implements them in this file. The configurations are -used literally as strings like "signature", "existence", etc. -""" - -from textwrap import dedent -from .loader import inspect - - -class SimpleNamespace(object): - # From types.rst, because the builtin is implemented in Python 3, only. - def __init__(self, **kwargs): - self.__dict__.update(kwargs) - - def __repr__(self): - keys = sorted(self.__dict__) - items = ("{}={!r}".format(k, self.__dict__[k]) for k in keys) - return "{}({})".format(type(self).__name__, ", ".join(items)) - - def __eq__(self, other): - return self.__dict__ == other.__dict__ - - -class SignatureLayout(SimpleNamespace): - """ - Configure a signature. - - The layout of signatures can have different layouts which are - controlled by keyword arguments: - - definition=True Determines if self will generated. - defaults=True - ellipsis=False Replaces defaults by "...". - return_annotation=True - parameter_names=True False removes names before ":". - """ - allowed_keys = SimpleNamespace(definition=True, - defaults=True, - ellipsis=False, - return_annotation=True, - parameter_names=True) - allowed_values = True, False - - def __init__(self, **kwds): - args = SimpleNamespace(**self.allowed_keys.__dict__) - args.__dict__.update(kwds) - self.__dict__.update(args.__dict__) - err_keys = list(set(self.__dict__) - set(self.allowed_keys.__dict__)) - if err_keys: - self._attributeerror(err_keys) - err_values = list(set(self.__dict__.values()) - set(self.allowed_values)) - if err_values: - self._valueerror(err_values) - - def __setattr__(self, key, value): - if key not in self.allowed_keys.__dict__: - self._attributeerror([key]) - if value not in self.allowed_values: - self._valueerror([value]) - self.__dict__[key] = value - - def _attributeerror(self, err_keys): - err_keys = ", ".join(err_keys) - allowed_keys = ", ".join(self.allowed_keys.__dict__.keys()) - raise AttributeError(dedent("""\ - Not allowed: '{err_keys}'. - The only allowed keywords are '{allowed_keys}'. - """.format(**locals()))) - - def _valueerror(self, err_values): - err_values = ", ".join(map(str, err_values)) - allowed_values = ", ".join(map(str, self.allowed_values)) - raise ValueError(dedent("""\ - Not allowed: '{err_values}'. - The only allowed values are '{allowed_values}'. - """.format(**locals()))) - -# The following names are used literally in this module. -# This way, we avoid the dict hashing problem. -signature = SignatureLayout() - -existence = SignatureLayout(definition=False, - defaults=False, - return_annotation=False, - parameter_names=False) - -hintingstub = SignatureLayout(ellipsis=True) - -typeerror = SignatureLayout(definition=False, - return_annotation=False, - parameter_names=False) - - -def define_nameless_parameter(): - """ - Create Nameless Parameters - - A nameless parameter has a reduced string representation. - This is done by cloning the parameter type and overwriting its - __str__ method. The inner structure is still a valid parameter. - """ - def __str__(self): - # for Python 2, we must change self to be an instance of P - klass = self.__class__ - self.__class__ = P - txt = P.__str__(self) - self.__class__ = klass - txt = txt[txt.index(":") + 1:].strip() if ":" in txt else txt - return txt - - P = inspect.Parameter - newname = "NamelessParameter" - bases = P.__bases__ - body = dict(P.__dict__) # get rid of mappingproxy - if "__slots__" in body: - # __slots__ would create duplicates - for name in body["__slots__"]: - del body[name] - body["__str__"] = __str__ - return type(newname, bases, body) - - -NamelessParameter = define_nameless_parameter() - - -def make_signature_nameless(signature): - """ - Make a Signature Nameless - - We use an existing signature and change the type of its parameters. - The signature looks different, but is totally intact. - """ - for key in signature.parameters.keys(): - signature.parameters[key].__class__ = NamelessParameter - - -def create_signature(props, key): - if not props: - # empty signatures string - return - if isinstance(props["multi"], list): - # multi sig: call recursively - return list(create_signature(elem, key) - for elem in props["multi"]) - if type(key) is tuple: - sig_kind, modifier = key - else: - sig_kind, modifier = key, "signature" - - layout = globals()[modifier] # lookup of the modifier in this module - if not isinstance(layout, SignatureLayout): - raise SystemError("Modifiers must be names of a SignatureLayout " - "instance") - - # this is the basic layout of a signature - varnames = props["varnames"] - if layout.definition: - if sig_kind == "function": - pass - elif sig_kind == "method": - varnames = ("self",) + varnames - elif sig_kind == "staticmethod": - pass - elif sig_kind == "classmethod": - varnames = ("klass",) + varnames - else: - raise SystemError("Methods must be function, method, staticmethod or " - "classmethod") - # calculate the modifications - defaults = props["defaults"][:] - if not layout.defaults: - defaults = () - if layout.ellipsis: - defaults = ("...",) * len(defaults) - annotations = props["annotations"].copy() - if not layout.return_annotation and "return" in annotations: - del annotations["return"] - - # attach parameters to a fake function and build a signature - argstr = ", ".join(varnames) - fakefunc = eval("lambda {}: None".format(argstr)) - fakefunc.__name__ = props["name"] - fakefunc.__defaults__ = defaults - fakefunc.__kwdefaults__ = props["kwdefaults"] - fakefunc.__annotations__ = annotations - sig = inspect._signature_from_function(inspect.Signature, fakefunc) - - # the special case of nameless parameters - if not layout.parameter_names: - make_signature_nameless(sig) - return sig - -# end of file +from signature_loader.layout import * |