Lines Matching refs:self
800 self = obj.__self__
801 if (isclass(self) and
802 getattr(getattr(self, name, None), '__func__') is obj.__func__):
804 cls = self
806 cls = self.__class__
814 self = obj.__self__
815 if (isclass(self) and
816 self.__qualname__ + '.' + name == obj.__qualname__):
818 cls = self
820 cls = self.__class__
1026 def __init__(self, qualname):
1027 self.stack = []
1028 self.qualname = qualname
1030 def visit_FunctionDef(self, node):
1031 self.stack.append(node.name)
1032 self.stack.append('<locals>')
1033 self.generic_visit(node)
1034 self.stack.pop()
1035 self.stack.pop()
1039 def visit_ClassDef(self, node):
1040 self.stack.append(node.name)
1041 if self.qualname == '.'.join(self.stack):
1051 self.generic_visit(node)
1052 self.stack.pop()
1172 def __init__(self):
1173 self.indent = 0
1174 self.islambda = False
1175 self.started = False
1176 self.passline = False
1177 self.indecorator = False
1178 self.last = 1
1179 self.body_col0 = None
1181 def tokeneater(self, type, token, srowcol, erowcol, line):
1182 if not self.started and not self.indecorator:
1185 self.indecorator = True
1189 self.islambda = True
1190 self.started = True
1191 self.passline = True # skip to the end of the line
1193 self.passline = False # stop skipping when a NEWLINE is seen
1194 self.last = srowcol[0]
1195 if self.islambda: # lambdas always end at the first NEWLINE
1199 if self.indecorator:
1200 self.indecorator = False
1201 elif self.passline:
1204 if self.body_col0 is None and self.started:
1205 self.body_col0 = erowcol[1]
1206 self.indent = self.indent + 1
1207 self.passline = True
1209 self.indent = self.indent - 1
1213 if self.indent <= 0:
1216 if self.body_col0 is not None and srowcol[1] >= self.body_col0:
1218 self.last = srowcol[0]
1219 elif self.indent == 0 and type not in (tokenize.COMMENT, tokenize.NL):
1349 - the "self" parameter is always reported, even for bound methods
1356 # and Signature: the former always returns 'self' parameter for bound
1361 # inspect.signature to always return their first parameter ("self",
1535 # implicit 'self' (or 'cls' for classmethods) argument
1645 def __repr__(self):
1648 self.filename, self.lineno, self.function, self.code_context,
1649 self.index, self.positions))
1717 def __repr__(self):
1720 self.frame, self.filename, self.lineno, self.function,
1721 self.code_context, self.index, self.positions))
2109 * the index of the "self" parameter (generally 0), or None if
2110 the function does not have a "self" parameter, and
2227 def visit_Attribute(self, node):
2239 def visit_Name(self, node):
2244 def visit_BinOp(self, node):
2247 left = self.visit(node.left)
2248 right = self.visit(node.right)
2310 # for builtins, self parameter is always positional-only!
2453 # function (usually `self` or `cls`).
2469 # skip its first parameter (self).
2495 # (usually `self`, or `cls`) will not be passed
2644 def __str__(self):
2645 return self.name
2686 def __init__(self, name, kind, *, default=_empty, annotation=_empty):
2688 self._kind = _ParameterKind(kind)
2692 if self._kind in (_VAR_POSITIONAL, _VAR_KEYWORD):
2694 msg = msg.format(self._kind.description)
2696 self._default = default
2697 self._annotation = annotation
2711 if self._kind != _POSITIONAL_OR_KEYWORD:
2716 msg = msg.format(self._kind.description)
2718 self._kind = _POSITIONAL_ONLY
2723 is_keyword = iskeyword(name) and self._kind is not _POSITIONAL_ONLY
2727 self._name = name
2729 def __reduce__(self):
2730 return (type(self),
2731 (self._name, self._kind),
2732 {'_default': self._default,
2733 '_annotation': self._annotation})
2735 def __setstate__(self, state):
2736 self._default = state['_default']
2737 self._annotation = state['_annotation']
2740 def name(self):
2741 return self._name
2744 def default(self):
2745 return self._default
2748 def annotation(self):
2749 return self._annotation
2752 def kind(self):
2753 return self._kind
2755 def replace(self, *, name=_void, kind=_void,
2760 name = self._name
2763 kind = self._kind
2766 annotation = self._annotation
2769 default = self._default
2771 return type(self)(name, kind, default=default, annotation=annotation)
2773 def __str__(self):
2774 kind = self.kind
2775 formatted = self._name
2778 if self._annotation is not _empty:
2780 formatannotation(self._annotation))
2782 if self._default is not _empty:
2783 if self._annotation is not _empty:
2784 formatted = '{} = {}'.format(formatted, repr(self._default))
2786 formatted = '{}={}'.format(formatted, repr(self._default))
2795 def __repr__(self):
2796 return '<{} "{}">'.format(self.__class__.__name__, self)
2798 def __hash__(self):
2799 return hash((self.name, self.kind, self.annotation, self.default))
2801 def __eq__(self, other):
2802 if self is other:
2806 return (self._name == other._name and
2807 self._kind == other._kind and
2808 self._default == other._default and
2809 self._annotation == other._annotation)
2831 def __init__(self, signature, arguments):
2832 self.arguments = arguments
2833 self._signature = signature
2836 def signature(self):
2837 return self._signature
2840 def args(self):
2842 for param_name, param in self._signature.parameters.items():
2847 arg = self.arguments[param_name]
2863 def kwargs(self):
2866 for param_name, param in self._signature.parameters.items():
2871 if param_name not in self.arguments:
2879 arg = self.arguments[param_name]
2892 def apply_defaults(self):
2901 arguments = self.arguments
2903 for name, param in self._signature.parameters.items():
2918 self.arguments = dict(new_arguments)
2920 def __eq__(self, other):
2921 if self is other:
2925 return (self.signature == other.signature and
2926 self.arguments == other.arguments)
2928 def __setstate__(self, state):
2929 self._signature = state['_signature']
2930 self.arguments = state['arguments']
2932 def __getstate__(self):
2933 return {'_signature': self._signature, 'arguments': self.arguments}
2935 def __repr__(self):
2937 for arg, value in self.arguments.items():
2939 return '<{} ({})>'.format(self.__class__.__name__, ', '.join(args))
2972 def __init__(self, parameters=None, *, return_annotation=_empty,
3021 self._parameters = types.MappingProxyType(params)
3022 self._return_annotation = return_annotation
3033 def parameters(self):
3034 return self._parameters
3037 def return_annotation(self):
3038 return self._return_annotation
3040 def replace(self, *, parameters=_void, return_annotation=_void):
3047 parameters = self.parameters.values()
3050 return_annotation = self._return_annotation
3052 return type(self)(parameters,
3055 def _hash_basis(self):
3056 params = tuple(param for param in self.parameters.values()
3059 kwo_params = {param.name: param for param in self.parameters.values()
3062 return params, kwo_params, self.return_annotation
3064 def __hash__(self):
3065 params, kwo_params, return_annotation = self._hash_basis()
3069 def __eq__(self, other):
3070 if self is other:
3074 return self._hash_basis() == other._hash_basis()
3076 def _bind(self, args, kwargs, *, partial=False):
3081 parameters = iter(self.parameters.values())
3205 return self._bound_arguments_cls(self, arguments)
3207 def bind(self, /, *args, **kwargs):
3212 return self._bind(args, kwargs)
3214 def bind_partial(self, /, *args, **kwargs):
3219 return self._bind(args, kwargs, partial=True)
3221 def __reduce__(self):
3222 return (type(self),
3223 (tuple(self._parameters.values()),),
3224 {'_return_annotation': self._return_annotation})
3226 def __setstate__(self, state):
3227 self._return_annotation = state['_return_annotation']
3229 def __repr__(self):
3230 return '<{} {}>'.format(self.__class__.__name__, self)
3232 def __str__(self):
3236 for param in self.parameters.values():
3271 if self.return_annotation is not _empty:
3272 anno = formatannotation(self.return_annotation)