o bR@sddZddlmZmZmZddlZddlZddlZddlm Z m Z m Z ddl m Z Gddde ZdS)zUnit tests for the pylint checkers in :mod:`pylint.extensions.check_docs`, in particular the parameter documentation checker `DocstringChecker` )divisionprint_functionabsolute_importN)CheckerTestCaseMessage set_config)DocstringParameterCheckerc@s,eZdZdZeZddiZddZddZdd Z d d Z d d Z ddZ ddZ ddZddZddZeddddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Z d8d9Z!d:d;Z"dd?Z$d@dAZ%dBdCZ&dDdEZ'dFdGZ(dHdIZ)dJdKZ*dLdMZ+dNdOZ,dPdQZ-e.j/j0e1j2dRdSkdTdUdVdWZ3dXdYZ4dZd[Z5d\d]Z6d^d_Z7d`daZ8dbdcZ9dddeZ:dfdgZ;dhdiZdndoZ?dpdqZ@drdsZAgdtZBeBgduZCe.j/DdveCdwdxZEe.j/DdveCdydzZFe.j/DdveCd{d|ZGe.j/Dd}eBd~dZHddZIddZJddZKddZLddZMddZNddZOddZMddZNddZPddZQddZRddZSddZTddZUddZVddZWddZXddZYddZZddZ[ddZ\ddZ]ddZ^ddZ_ddZ]ddZ^dS)TestParamDocCheckerz'Tests for pylint_plugin.ParamDocCheckeraccept_no_param_docFcC\td}|td|ddtd|dd|j|WddS1s'wYdS)zcExample of a function with missing Sphinx parameter documentation in the docstring z def function_foo(x, y, z): '''docstring ... :param x: bla :param int z: bar ''' pass missing-param-docymsg_idnodeargsmissing-type-doczx, yNastroid extract_nodeassertAddsMessagesrcheckervisit_functiondefselfrre/var/www/secure340b-portal/env/lib/python3.10/site-packages/pylint/test/extensions/test_check_docs.py,test_missing_func_params_in_sphinx_docstring&s   "z@TestParamDocChecker.test_missing_func_params_in_sphinx_docstringcCr )ziExample of a function with missing Google style parameter documentation in the docstring z def function_foo(x, y, z): '''docstring ... Args: x: bla z (int): bar some other stuff ''' pass r r rrrNrrrrr,test_missing_func_params_in_google_docstring@s   "z@TestParamDocChecker.test_missing_func_params_in_google_docstringcCDtd}||j|WddS1swYdS)jExample of a function with missing Google style parameter documentation in the docstring. z def function_foo(x: int, y: bool, z): '''docstring ... Args: x: bla y: blah blah z (int): bar some other stuff ''' pass NrrassertNoMessagesrrrrrr=test_missing_func_params_with_annotations_in_google_docstring\  "zQTestParamDocChecker.test_missing_func_params_with_annotations_in_google_docstringcCr!)r"z def function_foo(x: int, y: bool, z: int = 786): '''docstring ... Args: x: bla y: blah blah z: bar some other stuff ''' pass Nr#rrrr5test_default_arg_with_annotations_in_google_docstringpr&zITestParamDocChecker.test_default_arg_with_annotations_in_google_docstringcCsPtd}|td|dd|j|WddS1s!wYdS)r"z def function_foo(x, y: bool, z): '''docstring ... Args: x: bla y: blah blah z (int): bar some other stuff ''' pass rxrNrrrrrEtest_missing_func_params_with_partial_annotations_in_google_docstrings  "zYTestParamDocChecker.test_missing_func_params_with_partial_annotations_in_google_docstringcCr!)r"a* def area(bottomleft: Point, topright: Point) -> float: '''Calculate area of fake rectangle. Args: bottomleft: bottom left point of rectangle topright: top right point of rectangle ''' pass Nr#rrrr0test_non_builtin_annotations_in_google_docstring  "zDTestParamDocChecker.test_non_builtin_annotations_in_google_docstringcCr!)r"a6 def get_midpoint(bottomleft: Point, topright: Point) -> Point: '''Calculate midpoint of fake rectangle. Args: bottomleft: bottom left point of rectangle topright: top right point of rectangle ''' pass Nr#rrrr?test_non_builtin_annotations_for_returntype_in_google_docstringr,zSTestParamDocChecker.test_non_builtin_annotations_for_returntype_in_google_docstringcCr!)zuExample of a function with Google style parameter splitted in Args and Keyword Args in the docstring aV def my_func(this, other, that=True): '''Prints this, other and that Args: this (str): Printed first other (int): Other args Keyword Args: that (bool): Printed second ''' print(this, that, other) Nr#rrrr7test_func_params_and_keyword_params_in_google_docstringr&zKTestParamDocChecker.test_func_params_and_keyword_params_in_google_docstringc Csttd}|td|ddtd|ddtd|ddtd|dd|j|Wd d S1s3wYd S) zExample of a function with Google style parameter splitted in Args and Keyword Args in the docstring but with wrong keyword args aW def my_func(this, other, that=True): '''Prints this, other and that Args: this (str): Printed first other (int): Other args Keyword Args: these (bool): Printed second ''' print(this, that, other) r )thatrrdiffering-param-doc)Zthesediffering-type-docNrrrrr=test_func_params_and_wrong_keyword_params_in_google_docstrings2  "zQTestParamDocChecker.test_func_params_and_wrong_keyword_params_in_google_docstringcCr )zhExample of a function with missing NumPy style parameter documentation in the docstring a def function_foo(x, y, z): '''docstring ... Parameters ---------- x: bla z: int bar some other stuff ''' pass r r rrrNrrrrr+test_missing_func_params_in_numpy_docstrings  "z?TestParamDocChecker.test_missing_func_params_in_numpy_docstringT)r cCr!)zkExample of a function with no parameter documentation at all No error message is emitted. def function_foo(x, y): '''docstring ... missing parameter documentation''' pass Nr#rrrr+test_tolerate_no_param_documentation_at_alls  "z?TestParamDocChecker.test_tolerate_no_param_documentation_at_allcCs\td}|td|ddtd|dd|j|WddS1s'wYdS)z~Example of a function with no parameter documentation at all Missing documentation error message is emitted. r4r rrrNrrrrr1test_don_t_tolerate_no_param_documentation_at_all%s  "zETestParamDocChecker.test_don_t_tolerate_no_param_documentation_at_allcCr!)zgExample for the usage of "For the parameters, see" to suppress missing-param warnings. z def function_foo(x, y): '''docstring ... For the parameters, see :func:`blah` ''' pass Nr#rrrr/test_see_tolerate_no_param_documentation_at_all=s  "zCTestParamDocChecker.test_see_tolerate_no_param_documentation_at_allcCs2|jD]}t|tjrt|dr|j|qdS)zVisit all methods of a class node :param node: class node :type node: :class:`astroid.scoped_nodes.Class` nameN)body isinstancer FunctionDefhasattrrr)rrZ body_itemrrr_visit_methods_of_classLs   z+TestParamDocChecker._visit_methods_of_classcCdtd}|jd}|td|ddtd|dd||WddS1s+wYdS) zmExample of a class method with missing parameter documentation in the Sphinx style docstring z class Foo(object): def method_foo(self, x, y): '''docstring ... missing parameter documentation :param x: bla ''' pass rr r rrrNrrr9rrr=rrZ method_noderrr.test_missing_method_params_in_sphinx_docstringWs   "zBTestParamDocChecker.test_missing_method_params_in_sphinx_docstringcCr>) zmExample of a class method with missing parameter documentation in the Google style docstring z class Foo(object): def method_foo(self, x, y): '''docstring ... missing parameter documentation Args: x: bla ''' pass rr r rrrNr?r@rrr.test_missing_method_params_in_google_docstringss   "zBTestParamDocChecker.test_missing_method_params_in_google_docstringcCr>) zlExample of a class method with missing parameter documentation in the Numpy style docstring a) class Foo(object): def method_foo(self, x, y): '''docstring ... missing parameter documentation Parameters ---------- x: bla ''' pass rr r rrrNr?r@rrr-test_missing_method_params_in_numpy_docstrings   "zATestParamDocChecker.test_missing_method_params_in_numpy_docstringcCr!)zlExample of a function with correctly documented parameters and return values (Sphinx style) a def function_foo(xarg, yarg, zarg, warg): '''function foo ... :param xarg: bla xarg :type xarg: int :parameter yarg: bla yarg :type yarg: my.qualified.type :arg int zarg: bla zarg :keyword my.qualified.type warg: bla warg :return: sum :rtype: float ''' return xarg + yarg Nr#rrrr-test_existing_func_params_in_sphinx_docstrings  "zATestParamDocChecker.test_existing_func_params_in_sphinx_docstringcCr!)zlExample of a function with correctly documented parameters and return values (Google style) a def function_foo(xarg, yarg, zarg, warg): '''function foo ... Args: xarg (int): bla xarg yarg (my.qualified.type): bla bla yarg zarg (int): bla zarg warg (my.qualified.type): bla warg Returns: float: sum ''' return xarg + yarg Nr#rrrr-test_existing_func_params_in_google_docstrings  "zATestParamDocChecker.test_existing_func_params_in_google_docstringcCr!)zkExample of a function with correctly documented parameters and return values (Numpy style) a def function_foo(xarg, yarg, zarg, warg): '''function foo ... Parameters ---------- xarg: int bla xarg yarg: my.qualified.type bla yarg zarg: int bla zarg warg: my.qualified.type bla warg Returns ------- float sum ''' return xarg + yarg Nr#rrrr,test_existing_func_params_in_numpy_docstrings  "z@TestParamDocChecker.test_existing_func_params_in_numpy_docstringc Cstd}|td|ddtd|ddtd|ddtd |d d|j|Wd n1s2wYtd }|td|d dtd |d d|j|Wd d S1s^wYd S)z~Example of functions with inconsistent parameter names in the signature and in the Sphinx style documentation a. def function_foo(xarg, yarg, zarg): '''function foo ... :param xarg1: bla xarg :type xarg: int :param yarg: bla yarg :type yarg1: float :param str zarg1: bla zarg ''' return xarg + yarg r z xarg, zargrr)z yarg, zargr0z xarg1, zarg1r1)z yarg1, zarg1Nz def function_foo(xarg, yarg): '''function foo ... :param yarg1: bla yarg :type yarg1: float For the other parameters, see bla. ''' return xarg + yarg Zyarg1rrrrr2test_wrong_name_of_func_params_in_sphinx_docstringsP    "zFTestParamDocChecker.test_wrong_name_of_func_params_in_sphinx_docstringc Ctd}|td|ddtd|ddtd|ddtd|dd|j|Wd n1s2wYtd }|td|d dtd|d d|j|Wd d S1s^wYd S) z~Example of functions with inconsistent parameter names in the signature and in the Google style documentation a  def function_foo(xarg, yarg, zarg): '''function foo ... Args: xarg1 (int): bla xarg yarg (float): bla yarg zarg1 (str): bla zarg ''' return xarg + yarg r rGrrr0rHr1Nz def function_foo(xarg, yarg): '''function foo ... Args: yarg1 (float): bla yarg For the other parameters, see bla. ''' return xarg + yarg rIrrrrr2test_wrong_name_of_func_params_in_google_docstring<sP     "zFTestParamDocChecker.test_wrong_name_of_func_params_in_google_docstringc CrK) z}Example of functions with inconsistent parameter names in the signature and in the Numpy style documentation aE def function_foo(xarg, yarg, zarg): '''function foo ... Parameters ---------- xarg1: int bla xarg yarg: float bla yarg zarg1: str bla zarg ''' return xarg + yarg r rGrrr0rHr1Na def function_foo(xarg, yarg): '''function foo ... Parameters ---------- yarg1: float bla yarg For the other parameters, see bla. ''' return xarg + yarg rIrrrrr1test_wrong_name_of_func_params_in_numpy_docstringwsP    "zETestParamDocChecker.test_wrong_name_of_func_params_in_numpy_docstringcCr!)zExample for the usage of "For the other parameters, see" to avoid too many repetitions, e.g. in functions or methods adhering to a given interface (Sphinx style) z def function_foo(xarg, yarg): '''function foo ... :param yarg: bla yarg :type yarg: float For the other parameters, see :func:`bla` ''' return xarg + yarg Nr#rrrr5test_see_sentence_for_func_params_in_sphinx_docstring  "zITestParamDocChecker.test_see_sentence_for_func_params_in_sphinx_docstringcCr!)zExample for the usage of "For the other parameters, see" to avoid too many repetitions, e.g. in functions or methods adhering to a given interface (Google style) z def function_foo(xarg, yarg): '''function foo ... Args: yarg (float): bla yarg For the other parameters, see :func:`bla` ''' return xarg + yarg Nr#rrrr5test_see_sentence_for_func_params_in_google_docstringrOzITestParamDocChecker.test_see_sentence_for_func_params_in_google_docstringcCr!)zExample for the usage of "For the other parameters, see" to avoid too many repetitions, e.g. in functions or methods adhering to a given interface (Numpy style) a def function_foo(xarg, yarg): '''function foo ... Parameters ---------- yarg: float bla yarg For the other parameters, see :func:`bla` ''' return xarg + yarg Nr#rrrr4test_see_sentence_for_func_params_in_numpy_docstrings  "zHTestParamDocChecker.test_see_sentence_for_func_params_in_numpy_docstringcCZtd}|td|ddtd|dd||WddS1s&wYdS)Example of a class with missing constructor parameter documentation (Sphinx style) Everything is completely analogous to functions. z class ClassFoo(object): '''docstring foo :param y: bla missing constructor parameter documentation ''' def __init__(self, x, y): pass r r(rrrNrrrrr=rrrr"test_constr_params_in_class_sphinxs   "z6TestParamDocChecker.test_constr_params_in_class_sphinxcCrR)Example of a class with missing constructor parameter documentation (Google style) Everything is completely analogous to functions. a class ClassFoo(object): '''docstring foo Args: y: bla missing constructor parameter documentation ''' def __init__(self, x, y): pass r r(rrrNrTrrrr"test_constr_params_in_class_googles  "z6TestParamDocChecker.test_constr_params_in_class_googlecCrR)Example of a class with missing constructor parameter documentation (Numpy style) Everything is completely analogous to functions. a* class ClassFoo(object): '''docstring foo Parameters ---------- y: bla missing constructor parameter documentation ''' def __init__(self, x, y): pass r r(rrrNrTrrrr!test_constr_params_in_class_numpy2s  "z5TestParamDocChecker.test_constr_params_in_class_numpycCBtd}|||WddS1swYdS)z|Example of a class with correct constructor parameter documentation and an attributes section (Numpy style) aM class ClassFoo(object): ''' Parameters ---------- foo : str Something. Attributes ---------- bar : str Something. ''' def __init__(self, foo): self.bar = None Nrrr$r=rrrr0test_constr_params_and_attributes_in_class_numpyTs   "zDTestParamDocChecker.test_constr_params_and_attributes_in_class_numpycCr>) rSa class ClassFoo(object): def __init__(self, x, y): '''docstring foo constructor :param y: bla missing constructor parameter documentation ''' pass rr r(rrrNr?rrZconstructor_noderrr!test_constr_params_in_init_sphinxk   "z5TestParamDocChecker.test_constr_params_in_init_sphinxcCr>) rVa class ClassFoo(object): def __init__(self, x, y): '''docstring foo constructor Args: y: bla missing constructor parameter documentation ''' pass rr r(rrrNr?r]rrr!test_constr_params_in_init_googler_z5TestParamDocChecker.test_constr_params_in_init_googlecCr>) rXaE class ClassFoo(object): def __init__(self, x, y): '''docstring foo constructor Parameters ---------- y: bla missing constructor parameter documentation ''' pass rr r(rrrNr?r]rrr test_constr_params_in_init_numpys   "z4TestParamDocChecker.test_constr_params_in_init_numpycCrZ)z=Example usage of "For the parameters, see" in class docstringz class ClassFoo(object): '''docstring foo For the parameters, see :func:`bla` ''' def __init__(self, x, y): '''init''' pass Nr[rrrr,test_see_sentence_for_constr_params_in_class  "z@TestParamDocChecker.test_see_sentence_for_constr_params_in_classcCrZ)z   "z?TestParamDocChecker.test_constr_params_in_class_and_init_sphinxc Cre) zExample of a class with missing constructor parameter documentation in both the init docstring and the class docstring (Google style) Everything is completely analogous to functions. a class ClassFoo(object): '''docstring foo Args: y: bla missing constructor parameter documentation ''' def __init__(self, x, y): '''docstring foo Args: y: bla missing constructor parameter documentation ''' pass rrfrr r(rrNrgr]rrr+test_constr_params_in_class_and_init_google#s>   "z?TestParamDocChecker.test_constr_params_in_class_and_init_googlec Cre) zExample of a class with missing constructor parameter documentation in both the init docstring and the class docstring (Numpy style) Everything is completely analogous to functions. a class ClassFoo(object): '''docstring foo Parameters ---------- y: bla missing constructor parameter documentation ''' def __init__(self, x, y): '''docstring foo Parameters ---------- y: bla missing constructor parameter documentation ''' pass rrfrr r(rrNrgr]rrr*test_constr_params_in_class_and_init_numpyXs>   "z>TestParamDocChecker.test_constr_params_in_class_and_init_numpyrzEnabled on Python 3)reasoncCs\td}|td|ddtd|dd|j|WddS1s'wYdS)Nz def my_func(arg, *, kwonly, missing_kwonly): """The docstring :param int arg: The argument. :param bool kwonly: A keyword-arg. """ r )Zmissing_kwonlyrrrrrrr$test_kwonlyargs_are_taken_in_accounts  "z8TestParamDocChecker.test_kwonlyargs_are_taken_in_accountcCPtd}|td|dd|j|WddS1s!wYdS)Na( def my_func(named_arg, *args): """The docstring :param named_arg: Returned :type named_arg: object :returns: Maybe named_arg :rtype: object or None """ if args: return named_arg r rrrrrrrtest_warns_missing_args_sphinx  "z2TestParamDocChecker.test_warns_missing_args_sphinxcCrn)Na- def my_func(named_arg, **kwargs): """The docstring :param named_arg: Returned :type named_arg: object :returns: Maybe named_arg :rtype: object or None """ if kwargs: return named_arg r kwargsrrrrrr test_warns_missing_kwargs_sphinxrqz4TestParamDocChecker.test_warns_missing_kwargs_sphinxcCrn)Na def my_func(named_arg, *args): """The docstring Args: named_arg (object): Returned Returns: object or None: Maybe named_arg """ if args: return named_arg r rorrrrrrtest_warns_missing_args_google  "z2TestParamDocChecker.test_warns_missing_args_googlecCrn)Na def my_func(named_arg, **kwargs): """The docstring Args: named_arg (object): Returned Returns: object or None: Maybe named_arg """ if kwargs: return named_arg r rrrrrrrr test_warns_missing_kwargs_googlervz4TestParamDocChecker.test_warns_missing_kwargs_googlecCrn)NaZ def my_func(named_arg, *args): """The docstring Args ---- named_arg : object Returned Returns ------- object or None Maybe named_arg """ if args: return named_arg r rorrrrrrtest_warns_missing_args_numpy "z1TestParamDocChecker.test_warns_missing_args_numpycCrn)Na_ def my_func(named_arg, **kwargs): """The docstring Args ---- named_arg : object Returned Returns ------- object or None Maybe named_arg """ if kwargs: return named_arg r rrrrrrrrtest_warns_missing_kwargs_numpyryz3TestParamDocChecker.test_warns_missing_kwargs_numpycCDtd}||j|WddS1swYdS)NaT def my_func(named_arg, *args): """The docstring :param named_arg: Returned :type named_arg: object :param args: Optional arguments :returns: Maybe named_arg :rtype: object or None """ if args: return named_arg r#rrrr#test_finds_args_without_type_sphinx*  "z7TestParamDocChecker.test_finds_args_without_type_sphinxcCr{)NaZ def my_func(named_arg, **kwargs): """The docstring :param named_arg: Returned :type named_arg: object :param kwargs: Keyword arguments :returns: Maybe named_arg :rtype: object or None """ if kwargs: return named_arg r#rrrr%test_finds_kwargs_without_type_sphinx;r}z9TestParamDocChecker.test_finds_kwargs_without_type_sphinxcCr{)NaC def my_func(named_arg, *args): """The docstring Args: named_arg (object): Returned *args: Optional arguments Returns: object or None: Maybe named_arg """ if args: return named_arg r#rrrr#test_finds_args_without_type_googleL  "z7TestParamDocChecker.test_finds_args_without_type_googlecCr{)NaJ def my_func(named_arg, **kwargs): """The docstring Args: named_arg (object): Returned **kwargs: Keyword arguments Returns: object or None: Maybe named_arg """ if kwargs: return named_arg r#rrrr%test_finds_kwargs_without_type_google^rz9TestParamDocChecker.test_finds_kwargs_without_type_googlecCr{)Na def my_func(named_arg, *args): """The docstring Args ---- named_arg : object Returned args : Optional Arguments Returns ------- object or None Maybe named_arg """ if args: return named_arg r#rrrr"test_finds_args_without_type_numpyp  "z6TestParamDocChecker.test_finds_args_without_type_numpycCr{)NaT def my_func(named_arg, **kwargs): """The docstring Args: named_arg (`example.value`): Returned **kwargs: Keyword arguments Returns: `example.value`: Maybe named_arg """ if kwargs: return named_arg r#rrrr%test_finds_args_with_xref_type_googlerz9TestParamDocChecker.test_finds_args_with_xref_type_googlecCr{)Na def my_func(named_arg, *args): """The docstring Args ---- named_arg : `example.value` Returned args : Optional Arguments Returns ------- `example.value` Maybe named_arg """ if args: return named_arg r#rrrr$test_finds_args_with_xref_type_numpyrz8TestParamDocChecker.test_finds_args_with_xref_type_numpycCr{)Na def my_func(named_arg, **kwargs): """The docstring Args ---- named_arg : object Returned kwargs : Keyword arguments Returns ------- object or None Maybe named_arg """ if kwargs: return named_arg r#rrrr$test_finds_kwargs_without_type_numpyrz8TestParamDocChecker.test_finds_kwargs_without_type_numpy)z dict(str,str)z dict[str,str]z tuple(int)zlist[tokenize.TokenInfo])zdict(str, str)zdict[str, str]z int or strztuple(int or str)ztuple(int) or list(int)z%tuple(int or str) or list(int or str) complex_typecCJtd|}||j|WddS1swYdS)Nz def my_func(named_arg): """The docstring :param named_arg: Returned :type named_arg: {0} :returns: named_arg :rtype: {0} """ return named_arg rrformatr$rrrrrrrr test_finds_multiple_types_sphinx   "z4TestParamDocChecker.test_finds_multiple_types_sphinxcCr)Nz def my_func(named_arg): """The docstring Args: named_arg ({0}): Returned Returns: {0}: named_arg """ return named_arg rrrrr test_finds_multiple_types_googlerz4TestParamDocChecker.test_finds_multiple_types_googlecCr)Na& def my_func(named_arg): """The docstring Args ---- named_arg : {0} Returned Returns ------- {0} named_arg """ return named_arg rrrrrtest_finds_multiple_types_numpys  "z3TestParamDocChecker.test_finds_multiple_types_numpycontainer_typecCr)Nz def my_func(named_arg): """The docstring :param {0} named_arg: Returned :returns: named_arg :rtype: {0} """ return named_arg r)rrrrrr)test_finds_compact_container_types_sphinxs   "z=TestParamDocChecker.test_finds_compact_container_types_sphinxcCr{)Na def do_something(param1, param2, param3=(), param4=[], param5=[], param6=True): """Do something. Args: param1 (str): Description. param2 (dict(str, int)): Description. param3 (tuple(str), optional): Defaults to empty. Description. param4 (List[str], optional): Defaults to empty. Description. param5 (list[tuple(str)], optional): Defaults to empty. Description. param6 (bool, optional): Defaults to True. Description. Returns: int: Description. """ return param1, param2, param3, param4, param5, param6 r#rrrr&test_ignores_optional_specifier_googles  "z:TestParamDocChecker.test_ignores_optional_specifier_googlecCr{)Na def do_something(param, param2='all'): """Do something. Parameters ---------- param : str Description. param2 : str, optional Description (the default is 'all'). Returns ------- int Description. """ return param, param2 r#rrrr%test_ignores_optional_specifier_numpy3s  "z9TestParamDocChecker.test_ignores_optional_specifier_numpycCr{)Na from fake_package import BadError def do_something(): #@ """Do something. Raises: ~fake_package.exceptions.BadError: When something bad happened. """ raise BadError("A bad thing happened.") r#rrrrtest_finds_short_name_exceptionIs  "z3TestParamDocChecker.test_finds_short_name_exceptioncCTtd\}}|td|dd|j|WddS1s#wYdS)zvExample of a setter having missing raises documentation in the Sphinx style docstring of the property a( class Foo(object): @property def foo(self): #@ '''docstring ... :type: int ''' return 10 @foo.setter def foo(self, value): raise AttributeError() #@ missing-raises-docAttributeErrorrNrrrrrZ visit_raiserZ property_noderrrr,test_finds_missing_raises_from_setter_sphinxXs"z@TestParamDocChecker.test_finds_missing_raises_from_setter_sphinxcCr)zvExample of a setter having missing raises documentation in the Google style docstring of the property a class Foo(object): @property def foo(self): #@ '''int: docstring Include a "Raises" section so that this is identified as a Google docstring and not a Numpy docstring. Raises: RuntimeError: Always ''' raise RuntimeError() return 10 @foo.setter def foo(self, value): raises AttributeError() #@ rrrNrrrrr,test_finds_missing_raises_from_setter_googlers"z@TestParamDocChecker.test_finds_missing_raises_from_setter_googlecCr)zuExample of a setter having missing raises documentation in the Numpy style docstring of the property a" class Foo(object): @property def foo(self): #@ '''int: docstring Include a "Raises" section so that this is identified as a Numpy docstring and not a Google docstring. Raises ------ RuntimeError Always ''' raise RuntimeError() return 10 @foo.setter def foo(self, value): raises AttributeError() #@ rrrNrrrrr+test_finds_missing_raises_from_setter_numpys"z?TestParamDocChecker.test_finds_missing_raises_from_setter_numpycCr)zjExample of a setter having missing raises documentation in its own Sphinx style docstring a class Foo(object): @property def foo(self): '''docstring ... :type: int :raises RuntimeError: Always ''' raise RuntimeError() return 10 @foo.setter def foo(self, value): #@ '''setter docstring ... :type: None ''' raise AttributeError() #@ rrrNrrZ setter_noderrrr*test_finds_missing_raises_in_setter_sphinxs"z>TestParamDocChecker.test_finds_missing_raises_in_setter_sphinxcCr)zzExample of a setter having missing raises documentation in its own Google style docstring of the property a7 class Foo(object): @property def foo(self): '''int: docstring ... Raises: RuntimeError: Always ''' raise RuntimeError() return 10 @foo.setter def foo(self, value): #@ '''setter docstring ... Raises: RuntimeError: Never ''' if True: raise AttributeError() #@ raise RuntimeError() rrrNrrrrrrs"cCr)zyExample of a setter having missing raises documentation in its own Numpy style docstring of the property a class Foo(object): @property def foo(self): '''int: docstring ... Raises ------ RuntimeError Always ''' raise RuntimeError() return 10 @foo.setter def foo(self, value): #@ '''setter docstring ... Raises ------ RuntimeError Never ''' if True: raise AttributeError() #@ raise RuntimeError() rrrNrrrrrrs"cCr!)z^Example of a property having return documentation in a Sphinx style docstring z class Foo(object): @property def foo(self): #@ '''docstring ... :type: int ''' return 10 Nr#rrrr&test_finds_property_return_type_sphinx  "z:TestParamDocChecker.test_finds_property_return_type_sphinxcCr!)^Example of a property having return documentation in a Google style docstring a class Foo(object): @property def foo(self): #@ '''int: docstring ... Raises: RuntimeError: Always ''' raise RuntimeError() return 10 Nr#rrrr&test_finds_property_return_type_google-  "z:TestParamDocChecker.test_finds_property_return_type_googlecCr!)]Example of a property having return documentation in a numpy style docstring a8 class Foo(object): @property def foo(self): #@ '''int: docstring ... Raises ------ RuntimeError Always ''' raise RuntimeError() return 10 Nr#rrrr%test_finds_property_return_type_numpy@  "z9TestParamDocChecker.test_finds_property_return_type_numpycCHtd\}}||j|WddS1swYdS)fExample of a property having missing return documentation in a Sphinx style docstring a class Foo(object): @property def foo(self) -> int: #@ '''docstring ... :raises RuntimeError: Always ''' raise RuntimeError() return 10 #@ Nrrr$r visit_returnrrrr1test_finds_annotation_property_return_type_sphinxUs "zETestParamDocChecker.test_finds_annotation_property_return_type_sphinxcCRtd\}}|td|d|j|WddS1s"wYdS)rz class Foo(object): @property def foo(self): #@ '''docstring ... :raises RuntimeError: Always ''' raise RuntimeError() return 10 #@ missing-return-type-docrrNrrrrrrrrrr.test_finds_missing_property_return_type_sphinxgs "zBTestParamDocChecker.test_finds_missing_property_return_type_sphinxcCr)ra class Foo(object): @property def foo(self) -> int: #@ '''docstring ... Raises: RuntimeError: Always ''' raise RuntimeError() return 10 #@ Nrrrrr1test_finds_annotation_property_return_type_google}s "zETestParamDocChecker.test_finds_annotation_property_return_type_googlecCr)ra class Foo(object): @property def foo(self): #@ '''docstring ... Raises: RuntimeError: Always ''' raise RuntimeError() return 10 #@ rrNrrrrr.test_finds_missing_property_return_type_googles "zBTestParamDocChecker.test_finds_missing_property_return_type_googlecCr)ra6 class Foo(object): @property def foo(self): #@ '''docstring ... Raises ------ RuntimeError Always ''' raise RuntimeError() return 10 #@ rrNrrrrr-test_finds_missing_property_return_type_numpys"zATestParamDocChecker.test_finds_missing_property_return_type_numpycC\td\}}|td|dtd|d|j|WddS1s'wYdS)zuExample of a class function trying to use `type` as return documentation in a Sphinx style docstring z class Foo(object): def foo(self): #@ '''docstring ... :type: int ''' return 10 #@ missing-return-docrrNrrZ func_noderrrr,test_ignores_non_property_return_type_sphinxs "z@TestParamDocChecker.test_ignores_non_property_return_type_sphinxcCr)zuExample of a class function trying to use `type` as return documentation in a Google style docstring a class Foo(object): def foo(self): #@ '''int: docstring ... Raises: RuntimeError: Always ''' raise RuntimeError() return 10 #@ rrrNrrrrr,test_ignores_non_property_return_type_googles "z@TestParamDocChecker.test_ignores_non_property_return_type_googlecCr)tExample of a class function trying to use `type` as return documentation in a numpy style docstring a% class Foo(object): def foo(self): #@ '''int: docstring ... Raises ------ RuntimeError Always ''' raise RuntimeError() return 10 #@ rrrNrrrrr+test_ignores_non_property_return_type_numpys "z?TestParamDocChecker.test_ignores_non_property_return_type_numpycCr)ra, class Foo(object): def foo(self) -> int: #@ '''int: docstring ... Raises ------ RuntimeError Always ''' raise RuntimeError() return 10 #@ rrNrrrrr.test_non_property_annotation_return_type_numpy s "zBTestParamDocChecker.test_non_property_annotation_return_type_numpycCr!)pExample of an abstract method documenting the return type that an implementation should return. z import abc class Foo(object): @abc.abstractmethod def foo(self): #@ '''docstring ... :returns: Ten :rtype: int ''' return 10 Nr#rrrr-test_ignores_return_in_abstract_method_sphinx#rzATestParamDocChecker.test_ignores_return_in_abstract_method_sphinxcCr!)rz import abc class Foo(object): @abc.abstractmethod def foo(self): #@ '''docstring ... Returns: int: Ten ''' return 10 Nr#rrrr-test_ignores_return_in_abstract_method_google6rzATestParamDocChecker.test_ignores_return_in_abstract_method_googlecCr!)ra! import abc class Foo(object): @abc.abstractmethod def foo(self): #@ '''docstring ... Returns ------- int Ten ''' return 10 Nr#rrrr,test_ignores_return_in_abstract_method_numpyIrz@TestParamDocChecker.test_ignores_return_in_abstract_method_numpycCr!)zExample of an abstract z class Foo(object): def foo(self, arg): #@ '''docstring ... :param arg: An argument. :type arg: int ''' raise NotImplementedError() Nr#rrrr-test_ignores_raise_notimplementederror_sphinx^s  "zATestParamDocChecker.test_ignores_raise_notimplementederror_sphinxcCr!)fExample of a method documenting the return type that an implementation should return. z class Foo(object): def foo(self, arg): #@ '''docstring ... Args: arg (int): An argument. ''' raise NotImplementedError() Nr#rrrrrnrcCr!)ra class Foo(object): def foo(self, arg): #@ '''docstring ... Parameters ---------- arg : int An argument. ''' raise NotImplementedError() Nr#rrrrrrN)`__name__ __module__ __qualname____doc__rZ CHECKER_CLASSZCONFIGrr r%r'r*r+r-r.r2r3rr5r6r7r=rArBrCrDrErFrJrLrMrNrPrQrUrWrYr\r^r`rarbrdrhrirjpytestmarkZskipifsys version_informrprtrurwrxrzr|r~rrrrrrZCONTAINER_TYPESZ COMPLEX_TYPESZ parametrizerrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr s%  =;A "  "359         ! #' r )r __future__rrrrrrZpylint.testutilsrrrZpylint.extensions.docparamsrr rrrrs