1import abc
- 2import sched
- 3from functools import lru_cache
+ 2from functools import lru_cache
+ 3import sched
4from typing import Generic
5from typing import TypeVar
6
7from pdoc._compat import cached_property
8
- 9
- 10# https://github.com/mitmproxy/pdoc/issues/226
+ 9# https://github.com/mitmproxy/pdoc/issues/226
+ 10
11
- 12
- 13class Descriptor:
- 14 def __init__(self, func):
- 15 self.__doc__ = func.__doc__
- 16
- 17 def __get__(self, instance, owner):
- 18 return self if instance is None else getattr(instance, "_x", 0)
- 19
- 20 def __set__(self, instance, value):
- 21 instance._x = value
+ 12class Descriptor:
+ 13 def __init__(self, func):
+ 14 self.__doc__ = func.__doc__
+ 15
+ 16 def __get__(self, instance, owner):
+ 17 return self if instance is None else getattr(instance, "_x", 0)
+ 18
+ 19 def __set__(self, instance, value):
+ 20 instance._x = value
+ 21
22
- 23
- 24class Issue226:
- 25 @Descriptor
- 26 def size(self):
- 27 """This is the size"""
+ 23class Issue226:
+ 24 @Descriptor
+ 25 def size(self):
+ 26 """This is the size"""
+ 27
28
- 29
- 30# Testing function and object default values
+ 29# Testing function and object default values
+ 30
31
- 32
- 33def default_func():
- 34 pass
+ 32def default_func():
+ 33 pass
+ 34
35
- 36
- 37default_obj = object()
- 38
- 39var_with_default_obj = default_obj
- 40"""this shouldn't render the object address"""
- 41var_with_default_func = default_func
- 42"""this just renders like a normal function"""
+ 36default_obj = object()
+ 37
+ 38var_with_default_obj = default_obj
+ 39"""this shouldn't render the object address"""
+ 40var_with_default_func = default_func
+ 41"""this just renders like a normal function"""
+ 42
43
- 44
- 45def func_with_defaults(a=default_obj, b=default_func):
- 46 """this shouldn't render object or function addresses"""
- 47 pass
+ 44def func_with_defaults(a=default_obj, b=default_func):
+ 45 """this shouldn't render object or function addresses"""
+ 46 pass
+ 47
48
- 49
- 50# Testing classmethod links in code
- 51class ClassmethodLink:
- 52 """
- 53 You can either do
- 54
- 55 >>> ClassmethodLink.bar()
- 56 42
- 57
- 58 or
- 59
- 60 ```python
- 61 ClassmethodLink.bar()
- 62 ```
- 63
- 64 neither will be linked.
- 65 """
- 66
- 67 @classmethod
- 68 def bar(cls):
- 69 return 42
+ 49# Testing classmethod links in code
+ 50class ClassmethodLink:
+ 51 """
+ 52 You can either do
+ 53
+ 54 >>> ClassmethodLink.bar()
+ 55 42
+ 56
+ 57 or
+ 58
+ 59 ```python
+ 60 ClassmethodLink.bar()
+ 61 ```
+ 62
+ 63 neither will be linked.
+ 64 """
+ 65
+ 66 @classmethod
+ 67 def bar(cls):
+ 68 return 42
+ 69
70
- 71
- 72# Testing generic bases
- 73
- 74T = TypeVar("T")
+ 71# Testing generic bases
+ 72
+ 73T = TypeVar("T")
+ 74
75
- 76
- 77class GenericParent(Generic[T]):
- 78 pass
+ 76class GenericParent(Generic[T]):
+ 77 pass
+ 78
79
- 80
- 81class NonGenericChild(GenericParent[str]):
- 82 pass
+ 80class NonGenericChild(GenericParent[str]):
+ 81 pass
+ 82
83
- 84
- 85# Testing docstring inheritance
+ 84# Testing docstring inheritance
+ 85
86
- 87
- 88class Base:
- 89 def __init__(self):
- 90 """init"""
- 91 super().__init__()
- 92
- 93 def foo(self):
- 94 """foo"""
- 95 pass
- 96
- 97 @classmethod
- 98 def bar(cls):
- 99 """bar"""
-100 pass
-101
-102 @staticmethod
-103 def baz():
-104 """baz"""
-105 pass
-106
-107 @property
-108 def qux(self):
-109 """qux"""
-110 return
-111
-112 @cached_property
-113 def quux(self):
-114 """quux"""
-115 return
-116
-117 quuux: int = 42
-118 """quuux"""
+ 87class Base:
+ 88 def __init__(self):
+ 89 """init"""
+ 90 super().__init__()
+ 91
+ 92 def foo(self):
+ 93 """foo"""
+ 94 pass
+ 95
+ 96 @classmethod
+ 97 def bar(cls):
+ 98 """bar"""
+ 99 pass
+100
+101 @staticmethod
+102 def baz():
+103 """baz"""
+104 pass
+105
+106 @property
+107 def qux(self):
+108 """qux"""
+109 return
+110
+111 @cached_property
+112 def quux(self):
+113 """quux"""
+114 return
+115
+116 quuux: int = 42
+117 """quuux"""
+118
119
-120
-121class Child(Base):
-122 def __init__(self):
-123 super().__init__()
-124
-125 def foo(self):
-126 pass
-127
-128 @classmethod
-129 def bar(cls):
-130 pass
-131
-132 @staticmethod
-133 def baz():
-134 pass
-135
-136 @property
-137 def qux(self):
-138 return
-139
-140 @cached_property
-141 def quux(self):
-142 return
-143
-144 quuux: int = 42
+120class Child(Base):
+121 def __init__(self):
+122 super().__init__()
+123
+124 def foo(self):
+125 pass
+126
+127 @classmethod
+128 def bar(cls):
+129 pass
+130
+131 @staticmethod
+132 def baz():
+133 pass
+134
+135 @property
+136 def qux(self):
+137 return
+138
+139 @cached_property
+140 def quux(self):
+141 return
+142
+143 quuux: int = 42
+144
145
-146
-147# Testing that an attribute that is only annotated does not trigger a "submodule not found" warning.
-148
-149only_annotated: int
+146# Testing that an attribute that is only annotated does not trigger a "submodule not found" warning.
+147
+148only_annotated: int
+149
150
-151
-152# Testing that a private class in __all__ is displayed
+151# Testing that a private class in __all__ is displayed
+152
153
-154
-155class _Private:
-156 """private class"""
-157
-158 pass
-159
-160 def _do(self):
-161 """private method"""
+154class _Private:
+155 """private class"""
+156
+157 pass
+158
+159 def _do(self):
+160 """private method"""
+161
162
-163
-164# Testing a class attribute that is a lambda (which generates quirky sources)
+163# Testing a class attribute that is a lambda (which generates quirky sources)
+164
165
-166
-167class LambdaAttr:
-168 # not really supported, but also shouldn't crash.
-169 attr = lambda x: 42 # noqa
+166class LambdaAttr:
+167 # not really supported, but also shouldn't crash.
+168 attr = lambda x: 42 # noqa
+169
170
-171
-172# Testing different docstring annotations
-173# fmt: off
+171# Testing different docstring annotations
+172# fmt: off
+173
174
-175
-176def foo():
-177 """no indents"""
+175def foo():
+176 """no indents"""
+177
178
-179
-180def bar():
-181 """no
-182indents"""
+179def bar():
+180 """no
+181indents"""
+182
183
-184
-185def baz():
-186 """one
-187 indent"""
+184def baz():
+185 """one
+186 indent"""
+187
188
-189
-190def qux():
-191 """
-192 two
-193 indents
-194 """
+189def qux():
+190 """
+191 two
+192 indents
+193 """
+194
195
-196
-197class Indented:
-198 def foo(self):
-199 """no indents"""
-200
-201 def bar(self):
-202 """no
-203indents"""
-204
-205 def baz(self):
-206 """one
-207 indent"""
-208
-209 def qux(self):
-210 """
-211 two
-212 indents
-213 """
-214
-215 @lru_cache()
-216 def foo_decorated(self):
-217 """no indents"""
-218
-219 @lru_cache()
-220 # comment
-221 def foo_commented(self):
-222 """no indents"""
-223
-224 @lru_cache()
-225 def bar_decorated(self):
-226 """no
-227indents"""
-228
-229 @lru_cache()
-230 def baz_decorated(self):
-231 """one
-232 indent"""
-233
-234 @lru_cache()
-235 def qux_decorated(self):
-236 """
-237 two
-238 indents
-239 """
-240
-241 @lru_cache(
-242 maxsize=42
-243 )
-244 def quux_decorated(self):
-245 """multi-line decorator, https://github.com/mitmproxy/pdoc/issues/246"""
+196class Indented:
+197 def foo(self):
+198 """no indents"""
+199
+200 def bar(self):
+201 """no
+202indents"""
+203
+204 def baz(self):
+205 """one
+206 indent"""
+207
+208 def qux(self):
+209 """
+210 two
+211 indents
+212 """
+213
+214 @lru_cache()
+215 def foo_decorated(self):
+216 """no indents"""
+217
+218 @lru_cache()
+219 # comment
+220 def foo_commented(self):
+221 """no indents"""
+222
+223 @lru_cache()
+224 def bar_decorated(self):
+225 """no
+226indents"""
+227
+228 @lru_cache()
+229 def baz_decorated(self):
+230 """one
+231 indent"""
+232
+233 @lru_cache()
+234 def qux_decorated(self):
+235 """
+236 two
+237 indents
+238 """
+239
+240 @lru_cache(
+241 maxsize=42
+242 )
+243 def quux_decorated(self):
+244 """multi-line decorator, https://github.com/mitmproxy/pdoc/issues/246"""
+245
246
-247
-248def _protected_decorator(f):
-249 return f
+247def _protected_decorator(f):
+248 return f
+249
250
-251
-252@_protected_decorator
-253def fun_with_protected_decorator():
-254 """This function has a protected decorator (name starting with a single `_`)."""
+251@_protected_decorator
+252def fun_with_protected_decorator():
+253 """This function has a protected decorator (name starting with a single `_`)."""
+254
255
-256
-257class UnhashableDataDescriptor:
-258 def __get__(self):
-259 pass
-260 __hash__ = None # type: ignore
+256class UnhashableDataDescriptor:
+257 def __get__(self):
+258 pass
+259 __hash__ = None # type: ignore
+260
261
-262
-263unhashable = UnhashableDataDescriptor()
+262unhashable = UnhashableDataDescriptor()
+263
264
-265
-266class AbstractClass(metaclass=abc.ABCMeta):
-267 """This class shouldn't show a constructor as it's abstract."""
-268 @abc.abstractmethod
-269 def foo(self):
-270 pass
+265class AbstractClass(metaclass=abc.ABCMeta):
+266 """This class shouldn't show a constructor as it's abstract."""
+267 @abc.abstractmethod
+268 def foo(self):
+269 pass
+270
271
-272
-273# Adapted from https://github.com/mitmproxy/pdoc/issues/320
-274
-275def make_adder(a: int):
-276 def add_func(b: int) -> int:
-277 """This function adds two numbers."""
-278 return a + b
-279 return add_func
+272# Adapted from https://github.com/mitmproxy/pdoc/issues/320
+273
+274def make_adder(a: int):
+275 def add_func(b: int) -> int:
+276 """This function adds two numbers."""
+277 return a + b
+278 return add_func
+279
280
-281
-282add_four = make_adder(4)
-283add_five = make_adder(5)
-284"""This function adds five."""
-285add_six = make_adder(6)
-286add_six.__doc__ = "This function adds six."
+281add_four = make_adder(4)
+282add_five = make_adder(5)
+283"""This function adds five."""
+284add_six = make_adder(6)
+285add_six.__doc__ = "This function adds six."
+286
287
-288
-289# Adapted from https://github.com/mitmproxy/pdoc/issues/335
-290def linkify_links():
-291 """
-292 This docstring contains links that are also identifiers:
-293
-294 - [`linkify_links`](https://example.com/)
-295 - [misc.linkify_links](https://example.com/)
-296 - [`linkify_links()`](https://example.com/)
-297 - [misc.linkify_links()](https://example.com/)
-298 - [link in target](https://example.com/misc.linkify_links)
-299 - [explicit linking](#AbstractClass.foo)
-300 """
+288# Adapted from https://github.com/mitmproxy/pdoc/issues/335
+289def linkify_links():
+290 """
+291 This docstring contains links that are also identifiers:
+292
+293 - [`linkify_links`](https://example.com/)
+294 - [misc.linkify_links](https://example.com/)
+295 - [`linkify_links()`](https://example.com/)
+296 - [misc.linkify_links()](https://example.com/)
+297 - [link in target](https://example.com/misc.linkify_links)
+298 - [explicit linking](#AbstractClass.foo)
+299 """
+300
301
-302
-303class Issue352aMeta(type):
-304 def __call__(cls, *args, **kwargs):
-305 """Meta.__call__"""
+302class Issue352aMeta(type):
+303 def __call__(cls, *args, **kwargs):
+304 """Meta.__call__"""
+305
306
-307
-308class Issue352a(metaclass=Issue352aMeta):
-309 def __init__(self):
-310 """Issue352.__init__ should be preferred over Meta.__call__."""
+307class Issue352a(metaclass=Issue352aMeta):
+308 def __init__(self):
+309 """Issue352.__init__ should be preferred over Meta.__call__."""
+310
311
-312
-313class Issue352bMeta(type):
-314 def __call__(cls, *args, **kwargs):
-315 pass
+312class Issue352bMeta(type):
+313 def __call__(cls, *args, **kwargs):
+314 pass
+315
316
-317
-318class Issue352b(metaclass=Issue352bMeta):
-319 """No docstrings for the constructor here."""
+317class Issue352b(metaclass=Issue352bMeta):
+318 """No docstrings for the constructor here."""
+319
320
-321
-322class CustomCallMeta(type):
-323 def __call__(cls, *args, **kwargs):
-324 """Custom docstring in metaclass.`__call__`"""
+321class CustomCallMeta(type):
+322 def __call__(cls, *args, **kwargs):
+323 """Custom docstring in metaclass.`__call__`"""
+324
325
-326
-327class CustomCall(metaclass=CustomCallMeta):
-328 """A class where the constructor is defined by its metaclass."""
+326class CustomCall(metaclass=CustomCallMeta):
+327 """A class where the constructor is defined by its metaclass."""
+328
329
-330
-331class Headings:
-332 """
-333 # Heading 1
-334
-335 Here is some text.
-336
-337 ## Heading 2
-338
-339 Here is some text.
-340
-341 ### Heading 3
-342
-343 Here is some text.
-344
-345 #### Heading 4
-346
-347 Here is some text.
-348
-349 ##### Heading 5
-350
-351 Here is some text.
-352
-353 ###### Heading 6
-354
-355 Here is some text.
-356
-357 """
+330class Headings:
+331 """
+332 # Heading 1
+333
+334 Here is some text.
+335
+336 ## Heading 2
+337
+338 Here is some text.
+339
+340 ### Heading 3
+341
+342 Here is some text.
+343
+344 #### Heading 4
+345
+346 Here is some text.
+347
+348 ##### Heading 5
+349
+350 Here is some text.
+351
+352 ###### Heading 6
+353
+354 Here is some text.
+355
+356 """
+357
358
-359
-360class CustomRepr:
-361 def __repr__(self):
-362 return "°<script>alert(1)</script>"
+359class CustomRepr:
+360 def __repr__(self):
+361 return "°<script>alert(1)</script>"
+362
363
-364
-365def repr_not_syntax_highlightable(x=CustomRepr()):
-366 """The default value for x fails to highlight with pygments."""
+364def repr_not_syntax_highlightable(x=CustomRepr()):
+365 """The default value for x fails to highlight with pygments."""
+366
367
-368
-369class ClassDecorator:
-370 """This is a class that wraps a function. It will be documented correctly."""
-371 def __init__(self, f):
-372 self.f = f
+368class ClassDecorator:
+369 """This is a class that wraps a function. It will be documented correctly."""
+370 def __init__(self, f):
+371 self.f = f
+372
373
-374
-375@ClassDecorator
-376def another_decorated_function(arg: str) -> str:
-377 """This is another decorated function. It will not be documented correctly."""
-378 raise NotImplementedError
+374@ClassDecorator
+375def another_decorated_function(arg: str) -> str:
+376 """This is another decorated function. It will not be documented correctly."""
+377 raise NotImplementedError
+378
379
-380
-381class SubclassRef:
-382 class SubClass:
-383 pass
-384
-385 def __init__(self, x: "SubClass"):
-386 self.x = x
+380class SubclassRef:
+381 class SubClass:
+382 pass
+383
+384 def __init__(self, x: "SubClass"):
+385 self.x = x
+386
387
-388
-389class ClassAsAttribute:
-390 static_attr_to_class = ClassDecorator
-391 """this is a static attribute that point to a Class (not an instance)"""
-392
-393 static_attr_to_instance = ClassDecorator(None)
-394 """this is a static attribute that point to an instance"""
+388class ClassAsAttribute:
+389 static_attr_to_class = ClassDecorator
+390 """this is a static attribute that point to a Class (not an instance)"""
+391
+392 static_attr_to_instance = ClassDecorator(None)
+393 """this is a static attribute that point to an instance"""
+394
395
-396
-397class scheduler(sched.scheduler):
-398 """Test for broken links for inherited methods, https://github.com/mitmproxy/pdoc/issues/490"""
+396class scheduler(sched.scheduler):
+397 """Test for broken links for inherited methods, https://github.com/mitmproxy/pdoc/issues/490"""
+398
399
-400
-401class __init__:
-402 """https://github.com/mitmproxy/pdoc/issues/519"""
+400class __init__:
+401 """https://github.com/mitmproxy/pdoc/issues/519"""
+402
403
-404
-405def dynamically_modify_docstring1():
-406 """this should **not** be the docstring."""
+404def dynamically_modify_docstring1():
+405 """this should **not** be the docstring."""
+406
407
-408
-409def dynamically_modify_docstring2():
-410 pass
+408def dynamically_modify_docstring2():
+409 pass
+410
411
-412
-413dynamically_modify_docstring1.__doc__ = "https://github.com/mitmproxy/pdoc/issues/536"
-414dynamically_modify_docstring2.__doc__ = "https://github.com/mitmproxy/pdoc/issues/536"
+412dynamically_modify_docstring1.__doc__ = "https://github.com/mitmproxy/pdoc/issues/536"
+413dynamically_modify_docstring2.__doc__ = "https://github.com/mitmproxy/pdoc/issues/536"
+414
415
-416
-417def _docstring_modifier(fn):
-418 fn.__doc__ = "https://github.com/mitmproxy/pdoc/issues/536"
-419 return fn
+416def _docstring_modifier(fn):
+417 fn.__doc__ = "https://github.com/mitmproxy/pdoc/issues/536"
+418 return fn
+419
420
-421
-422@_docstring_modifier
-423def dynamically_modify_docstring3():
-424 """This should **not** be the docstring."""
+421@_docstring_modifier
+422def dynamically_modify_docstring3():
+423 """This should **not** be the docstring."""
+424
425
-426
-427@_docstring_modifier
-428def dynamically_modify_docstring4():
-429 pass
+426@_docstring_modifier
+427def dynamically_modify_docstring4():
+428 pass
+429
430
-431
-432__all__ = [
-433 "Issue226",
-434 "var_with_default_obj",
-435 "var_with_default_func",
-436 "func_with_defaults",
-437 "ClassmethodLink",
-438 "GenericParent",
-439 "NonGenericChild",
-440 "Child",
-441 "only_annotated",
-442 "_Private",
-443 "LambdaAttr",
-444 "foo",
-445 "bar",
-446 "baz",
-447 "qux",
-448 "Indented",
-449 "fun_with_protected_decorator",
-450 "unhashable",
-451 "AbstractClass",
-452 "add_four",
-453 "add_five",
-454 "add_six",
-455 "linkify_links",
-456 "Issue352a",
-457 "Issue352b",
-458 "CustomCall",
-459 "Headings",
-460 "repr_not_syntax_highlightable",
-461 "ClassDecorator",
-462 "another_decorated_function",
-463 "SubclassRef",
-464 "ClassAsAttribute",
-465 "scheduler",
-466 "__init__",
-467 "dynamically_modify_docstring1",
-468 "dynamically_modify_docstring2",
-469 "dynamically_modify_docstring3",
-470 "dynamically_modify_docstring4",
-471]
+431__all__ = [
+432 "Issue226",
+433 "var_with_default_obj",
+434 "var_with_default_func",
+435 "func_with_defaults",
+436 "ClassmethodLink",
+437 "GenericParent",
+438 "NonGenericChild",
+439 "Child",
+440 "only_annotated",
+441 "_Private",
+442 "LambdaAttr",
+443 "foo",
+444 "bar",
+445 "baz",
+446 "qux",
+447 "Indented",
+448 "fun_with_protected_decorator",
+449 "unhashable",
+450 "AbstractClass",
+451 "add_four",
+452 "add_five",
+453 "add_six",
+454 "linkify_links",
+455 "Issue352a",
+456 "Issue352b",
+457 "CustomCall",
+458 "Headings",
+459 "repr_not_syntax_highlightable",
+460 "ClassDecorator",
+461 "another_decorated_function",
+462 "SubclassRef",
+463 "ClassAsAttribute",
+464 "scheduler",
+465 "__init__",
+466 "dynamically_modify_docstring1",
+467 "dynamically_modify_docstring2",
+468 "dynamically_modify_docstring3",
+469 "dynamically_modify_docstring4",
+470]
- 25class Issue226:
-26 @Descriptor
-27 def size(self):
-28 """This is the size"""
+ 24class Issue226:
+25 @Descriptor
+26 def size(self):
+27 """This is the size"""
34def default_func():
-35 pass
+ 33def default_func():
+34 pass
46def func_with_defaults(a=default_obj, b=default_func):
-47 """this shouldn't render object or function addresses"""
-48 pass
+ 45def func_with_defaults(a=default_obj, b=default_func):
+46 """this shouldn't render object or function addresses"""
+47 pass
52class ClassmethodLink:
-53 """
-54 You can either do
-55
-56 >>> ClassmethodLink.bar()
-57 42
-58
-59 or
-60
-61 ```python
-62 ClassmethodLink.bar()
-63 ```
-64
-65 neither will be linked.
-66 """
-67
-68 @classmethod
-69 def bar(cls):
-70 return 42
+ 51class ClassmethodLink:
+52 """
+53 You can either do
+54
+55 >>> ClassmethodLink.bar()
+56 42
+57
+58 or
+59
+60 ```python
+61 ClassmethodLink.bar()
+62 ```
+63
+64 neither will be linked.
+65 """
+66
+67 @classmethod
+68 def bar(cls):
+69 return 42
68 @classmethod
-69 def bar(cls):
-70 return 42
+ 67 @classmethod
+68 def bar(cls):
+69 return 42
78class GenericParent(Generic[T]):
-79 pass
+ 77class GenericParent(Generic[T]):
+78 pass
82class NonGenericChild(GenericParent[str]):
-83 pass
+ 81class NonGenericChild(GenericParent[str]):
+82 pass
122class Child(Base):
-123 def __init__(self):
-124 super().__init__()
-125
-126 def foo(self):
-127 pass
-128
-129 @classmethod
-130 def bar(cls):
-131 pass
-132
-133 @staticmethod
-134 def baz():
-135 pass
-136
-137 @property
-138 def qux(self):
-139 return
-140
-141 @cached_property
-142 def quux(self):
-143 return
-144
-145 quuux: int = 42
+
@@ -1065,8 +1064,8 @@
123 def __init__(self):
-124 super().__init__()
+ 122 def __init__(self):
+123 super().__init__()
126 def foo(self):
-127 pass
+
@@ -1108,9 +1107,9 @@
129 @classmethod
-130 def bar(cls):
-131 pass
+ 128 @classmethod
+129 def bar(cls):
+130 pass
133 @staticmethod
-134 def baz():
-135 pass
+
@@ -1205,13 +1204,13 @@
156class _Private:
-157 """private class"""
-158
-159 pass
-160
-161 def _do(self):
-162 """private method"""
+ 155class _Private:
+156 """private class"""
+157
+158 pass
+159
+160 def _do(self):
+161 """private method"""
168class LambdaAttr:
-169 # not really supported, but also shouldn't crash.
-170 attr = lambda x: 42 # noqa
+ 167class LambdaAttr:
+168 # not really supported, but also shouldn't crash.
+169 attr = lambda x: 42 # noqa
170 attr = lambda x: 42 # noqa
+ 169 attr = lambda x: 42 # noqa
177def foo():
-178 """no indents"""
+ 176def foo():
+177 """no indents"""
181def bar():
-182 """no
-183indents"""
+
@@ -1313,9 +1312,9 @@
186def baz():
-187 """one
-188 indent"""
+
@@ -1336,11 +1335,11 @@
191def qux():
-192 """
-193 two
-194 indents
-195 """
+
@@ -1361,55 +1360,55 @@
198class Indented:
-199 def foo(self):
-200 """no indents"""
-201
-202 def bar(self):
-203 """no
-204indents"""
-205
-206 def baz(self):
-207 """one
-208 indent"""
-209
-210 def qux(self):
-211 """
-212 two
-213 indents
-214 """
-215
-216 @lru_cache()
-217 def foo_decorated(self):
-218 """no indents"""
-219
-220 @lru_cache()
-221 # comment
-222 def foo_commented(self):
-223 """no indents"""
-224
-225 @lru_cache()
-226 def bar_decorated(self):
-227 """no
-228indents"""
-229
-230 @lru_cache()
-231 def baz_decorated(self):
-232 """one
-233 indent"""
-234
-235 @lru_cache()
-236 def qux_decorated(self):
-237 """
-238 two
-239 indents
-240 """
-241
-242 @lru_cache(
-243 maxsize=42
-244 )
-245 def quux_decorated(self):
-246 """multi-line decorator, https://github.com/mitmproxy/pdoc/issues/246"""
+ 197class Indented:
+198 def foo(self):
+199 """no indents"""
+200
+201 def bar(self):
+202 """no
+203indents"""
+204
+205 def baz(self):
+206 """one
+207 indent"""
+208
+209 def qux(self):
+210 """
+211 two
+212 indents
+213 """
+214
+215 @lru_cache()
+216 def foo_decorated(self):
+217 """no indents"""
+218
+219 @lru_cache()
+220 # comment
+221 def foo_commented(self):
+222 """no indents"""
+223
+224 @lru_cache()
+225 def bar_decorated(self):
+226 """no
+227indents"""
+228
+229 @lru_cache()
+230 def baz_decorated(self):
+231 """one
+232 indent"""
+233
+234 @lru_cache()
+235 def qux_decorated(self):
+236 """
+237 two
+238 indents
+239 """
+240
+241 @lru_cache(
+242 maxsize=42
+243 )
+244 def quux_decorated(self):
+245 """multi-line decorator, https://github.com/mitmproxy/pdoc/issues/246"""
199 def foo(self):
-200 """no indents"""
+ 198 def foo(self):
+199 """no indents"""
202 def bar(self):
-203 """no
-204indents"""
+
@@ -1470,9 +1469,9 @@
206 def baz(self):
-207 """one
-208 indent"""
+ 205 def baz(self):
+206 """one
+207 indent"""
210 def qux(self):
-211 """
-212 two
-213 indents
-214 """
+
@@ -1519,9 +1518,9 @@
216 @lru_cache()
-217 def foo_decorated(self):
-218 """no indents"""
+ 215 @lru_cache()
+216 def foo_decorated(self):
+217 """no indents"""
225 @lru_cache()
-226 def bar_decorated(self):
-227 """no
-228indents"""
+ 224 @lru_cache()
+225 def bar_decorated(self):
+226 """no
+227indents"""
230 @lru_cache()
-231 def baz_decorated(self):
-232 """one
-233 indent"""
+ 229 @lru_cache()
+230 def baz_decorated(self):
+231 """one
+232 indent"""
235 @lru_cache()
-236 def qux_decorated(self):
-237 """
-238 two
-239 indents
-240 """
+
@@ -1643,11 +1642,11 @@
242 @lru_cache(
-243 maxsize=42
-244 )
-245 def quux_decorated(self):
-246 """multi-line decorator, https://github.com/mitmproxy/pdoc/issues/246"""
+ 241 @lru_cache(
+242 maxsize=42
+243 )
+244 def quux_decorated(self):
+245 """multi-line decorator, https://github.com/mitmproxy/pdoc/issues/246"""
253@_protected_decorator
-254def fun_with_protected_decorator():
-255 """This function has a protected decorator (name starting with a single `_`)."""
+ 252@_protected_decorator
+253def fun_with_protected_decorator():
+254 """This function has a protected decorator (name starting with a single `_`)."""
267class AbstractClass(metaclass=abc.ABCMeta):
-268 """This class shouldn't show a constructor as it's abstract."""
-269 @abc.abstractmethod
-270 def foo(self):
-271 pass
+ 266class AbstractClass(metaclass=abc.ABCMeta):
+267 """This class shouldn't show a constructor as it's abstract."""
+268 @abc.abstractmethod
+269 def foo(self):
+270 pass
269 @abc.abstractmethod
-270 def foo(self):
-271 pass
+ 268 @abc.abstractmethod
+269 def foo(self):
+270 pass
277 def add_func(b: int) -> int:
-278 """This function adds two numbers."""
-279 return a + b
+ 276 def add_func(b: int) -> int:
+277 """This function adds two numbers."""
+278 return a + b
277 def add_func(b: int) -> int:
-278 """This function adds two numbers."""
-279 return a + b
+ 276 def add_func(b: int) -> int:
+277 """This function adds two numbers."""
+278 return a + b
277 def add_func(b: int) -> int:
-278 """This function adds two numbers."""
-279 return a + b
+ 276 def add_func(b: int) -> int:
+277 """This function adds two numbers."""
+278 return a + b
291def linkify_links():
-292 """
-293 This docstring contains links that are also identifiers:
-294
-295 - [`linkify_links`](https://example.com/)
-296 - [misc.linkify_links](https://example.com/)
-297 - [`linkify_links()`](https://example.com/)
-298 - [misc.linkify_links()](https://example.com/)
-299 - [link in target](https://example.com/misc.linkify_links)
-300 - [explicit linking](#AbstractClass.foo)
-301 """
+ 290def linkify_links():
+291 """
+292 This docstring contains links that are also identifiers:
+293
+294 - [`linkify_links`](https://example.com/)
+295 - [misc.linkify_links](https://example.com/)
+296 - [`linkify_links()`](https://example.com/)
+297 - [misc.linkify_links()](https://example.com/)
+298 - [link in target](https://example.com/misc.linkify_links)
+299 - [explicit linking](#AbstractClass.foo)
+300 """
309class Issue352a(metaclass=Issue352aMeta):
-310 def __init__(self):
-311 """Issue352.__init__ should be preferred over Meta.__call__."""
+ 308class Issue352a(metaclass=Issue352aMeta):
+309 def __init__(self):
+310 """Issue352.__init__ should be preferred over Meta.__call__."""
310 def __init__(self):
-311 """Issue352.__init__ should be preferred over Meta.__call__."""
+ 309 def __init__(self):
+310 """Issue352.__init__ should be preferred over Meta.__call__."""
319class Issue352b(metaclass=Issue352bMeta):
-320 """No docstrings for the constructor here."""
+ 318class Issue352b(metaclass=Issue352bMeta):
+319 """No docstrings for the constructor here."""
328class CustomCall(metaclass=CustomCallMeta):
-329 """A class where the constructor is defined by its metaclass."""
+ 327class CustomCall(metaclass=CustomCallMeta):
+328 """A class where the constructor is defined by its metaclass."""
324 def __call__(cls, *args, **kwargs):
-325 """Custom docstring in metaclass.`__call__`"""
+ 323 def __call__(cls, *args, **kwargs):
+324 """Custom docstring in metaclass.`__call__`"""
366def repr_not_syntax_highlightable(x=CustomRepr()):
-367 """The default value for x fails to highlight with pygments."""
+ 365def repr_not_syntax_highlightable(x=CustomRepr()):
+366 """The default value for x fails to highlight with pygments."""
Heading 6
370class ClassDecorator:
-371 """This is a class that wraps a function. It will be documented correctly."""
-372 def __init__(self, f):
-373 self.f = f
+ 369class ClassDecorator:
+370 """This is a class that wraps a function. It will be documented correctly."""
+371 def __init__(self, f):
+372 self.f = f
Heading 6
372 def __init__(self, f):
-373 self.f = f
+ 371 def __init__(self, f):
+372 self.f = f
Heading 6
382class SubclassRef:
-383 class SubClass:
-384 pass
-385
-386 def __init__(self, x: "SubClass"):
-387 self.x = x
+ 381class SubclassRef:
+382 class SubClass:
+383 pass
+384
+385 def __init__(self, x: "SubClass"):
+386 self.x = x
Heading 6
386 def __init__(self, x: "SubClass"):
-387 self.x = x
+ 385 def __init__(self, x: "SubClass"):
+386 self.x = x
Heading 6
383 class SubClass:
-384 pass
+
@@ -2159,12 +2158,12 @@ Heading 6
390class ClassAsAttribute:
-391 static_attr_to_class = ClassDecorator
-392 """this is a static attribute that point to a Class (not an instance)"""
-393
-394 static_attr_to_instance = ClassDecorator(None)
-395 """this is a static attribute that point to an instance"""
+ 389class ClassAsAttribute:
+390 static_attr_to_class = ClassDecorator
+391 """this is a static attribute that point to a Class (not an instance)"""
+392
+393 static_attr_to_instance = ClassDecorator(None)
+394 """this is a static attribute that point to an instance"""
Heading 6
398class scheduler(sched.scheduler):
-399 """Test for broken links for inherited methods, https://github.com/mitmproxy/pdoc/issues/490"""
+ 397class scheduler(sched.scheduler):
+398 """Test for broken links for inherited methods, https://github.com/mitmproxy/pdoc/issues/490"""
Inherited Members
402class __init__:
-403 """https://github.com/mitmproxy/pdoc/issues/519"""
+ 401class __init__:
+402 """https://github.com/mitmproxy/pdoc/issues/519"""
Inherited Members
406def dynamically_modify_docstring1():
-407 """this should **not** be the docstring."""
+ 405def dynamically_modify_docstring1():
+406 """this should **not** be the docstring."""
Inherited Members
410def dynamically_modify_docstring2():
-411 pass
+ 409def dynamically_modify_docstring2():
+410 pass
Inherited Members
423@_docstring_modifier
-424def dynamically_modify_docstring3():
-425 """This should **not** be the docstring."""
+ 422@_docstring_modifier
+423def dynamically_modify_docstring3():
+424 """This should **not** be the docstring."""
Inherited Members
428@_docstring_modifier
-429def dynamically_modify_docstring4():
-430 pass
+ 427@_docstring_modifier
+428def dynamically_modify_docstring4():
+429 pass
9from typing import TypedDict
10from typing import Union
11
-12
-13# Testing a typing.NamedTuple
-14# we do not care very much about collections.namedtuple,
-15# the typing version is superior for documentation and a drop-in replacement.
+12# Testing a typing.NamedTuple
+13# we do not care very much about collections.namedtuple,
+14# the typing version is superior for documentation and a drop-in replacement.
+15
16
-17
-18class NamedTupleExample(NamedTuple):
-19 """
-20 An example for a typing.NamedTuple.
-21 """
-22
-23 name: str
-24 """Name of our example tuple."""
-25 id: int = 3
+17class NamedTupleExample(NamedTuple):
+18 """
+19 An example for a typing.NamedTuple.
+20 """
+21
+22 name: str
+23 """Name of our example tuple."""
+24 id: int = 3
+25
26
-27
-28# Testing some edge cases in our inlined implementation of ForwardRef._evaluate in _eval_type.
-29class Foo(TypedDict):
-30 a: Optional[int]
-31 """First attribute."""
+27# Testing some edge cases in our inlined implementation of ForwardRef._evaluate in _eval_type.
+28class Foo(TypedDict):
+29 a: Optional[int]
+30 """First attribute."""
+31
32
-33
-34class Bar(Foo, total=False):
-35 """A TypedDict subclass. TypedDict botches the MRO, so things aren't perfect here."""
-36
-37 b: int
-38 """Second attribute."""
-39 c: str
-40 # undocumented attribute
+33class Bar(Foo, total=False):
+34 """A TypedDict subclass. TypedDict botches the MRO, so things aren't perfect here."""
+35
+36 b: int
+37 """Second attribute."""
+38 c: str
+39 # undocumented attribute
+40
41
-42
-43class BarWorkaround(Foo, TypedDict, total=False):
-44 """
-45 A TypedDict subclass with the workaround to also inherit from TypedDict.
-46
-47 See https://github.com/sphinx-doc/sphinx/pull/10806.
-48 """
-49
-50 b: int
-51 """Second attribute."""
-52 c: str
-53 # undocumented attribute
+42class BarWorkaround(Foo, TypedDict, total=False):
+43 """
+44 A TypedDict subclass with the workaround to also inherit from TypedDict.
+45
+46 See https://github.com/sphinx-doc/sphinx/pull/10806.
+47 """
+48
+49 b: int
+50 """Second attribute."""
+51 c: str
+52 # undocumented attribute
+53
54
-55
-56class SingleDispatchMethodExample:
-57 @functools.singledispatchmethod
-58 def fancymethod(self, str_or_int: Union[str, int]):
-59 """A fancy method which is capable of handling either `str` or `int`.
-60
-61 :param str_or_int: string or integer to handle
-62 """
-63 raise NotImplementedError(f"{type(str_or_int)=} not implemented!")
-64
-65 @fancymethod.register
-66 def fancymethod_handle_str(self, str_to_handle: str):
-67 """Fancy method handles a string.
-68
-69 :param str_to_handle: string which will be handled
-70 """
-71 print(f"{type(str_to_handle)} = '{str_to_handle}")
-72
-73 @fancymethod.register
-74 def _fancymethod_handle_int(self, int_to_handle: int):
-75 """Fancy method handles int (not shown in doc).
-76
-77 :param int_to_handle: int which will be handled
-78 """
-79 print(f"{type(int_to_handle)} = '{int_to_handle:x}'")
+55class SingleDispatchMethodExample:
+56 @functools.singledispatchmethod
+57 def fancymethod(self, str_or_int: Union[str, int]):
+58 """A fancy method which is capable of handling either `str` or `int`.
+59
+60 :param str_or_int: string or integer to handle
+61 """
+62 raise NotImplementedError(f"{type(str_or_int)=} not implemented!")
+63
+64 @fancymethod.register
+65 def fancymethod_handle_str(self, str_to_handle: str):
+66 """Fancy method handles a string.
+67
+68 :param str_to_handle: string which will be handled
+69 """
+70 print(f"{type(str_to_handle)} = '{str_to_handle}")
+71
+72 @fancymethod.register
+73 def _fancymethod_handle_int(self, int_to_handle: int):
+74 """Fancy method handles int (not shown in doc).
+75
+76 :param int_to_handle: int which will be handled
+77 """
+78 print(f"{type(int_to_handle)} = '{int_to_handle:x}'")
- 19class NamedTupleExample(NamedTuple):
-20 """
-21 An example for a typing.NamedTuple.
-22 """
-23
-24 name: str
-25 """Name of our example tuple."""
-26 id: int = 3
+ 18class NamedTupleExample(NamedTuple):
+19 """
+20 An example for a typing.NamedTuple.
+21 """
+22
+23 name: str
+24 """Name of our example tuple."""
+25 id: int = 3
Inherited Members
30class Foo(TypedDict):
-31 a: Optional[int]
-32 """First attribute."""
+ 29class Foo(TypedDict):
+30 a: Optional[int]
+31 """First attribute."""
Inherited Members
35class Bar(Foo, total=False):
-36 """A TypedDict subclass. TypedDict botches the MRO, so things aren't perfect here."""
-37
-38 b: int
-39 """Second attribute."""
-40 c: str
-41 # undocumented attribute
+ 34class Bar(Foo, total=False):
+35 """A TypedDict subclass. TypedDict botches the MRO, so things aren't perfect here."""
+36
+37 b: int
+38 """Second attribute."""
+39 c: str
+40 # undocumented attribute
Inherited Members
44class BarWorkaround(Foo, TypedDict, total=False):
-45 """
-46 A TypedDict subclass with the workaround to also inherit from TypedDict.
-47
-48 See https://github.com/sphinx-doc/sphinx/pull/10806.
-49 """
-50
-51 b: int
-52 """Second attribute."""
-53 c: str
-54 # undocumented attribute
+ 43class BarWorkaround(Foo, TypedDict, total=False):
+44 """
+45 A TypedDict subclass with the workaround to also inherit from TypedDict.
+46
+47 See https://github.com/sphinx-doc/sphinx/pull/10806.
+48 """
+49
+50 b: int
+51 """Second attribute."""
+52 c: str
+53 # undocumented attribute
Inherited Members
57class SingleDispatchMethodExample:
-58 @functools.singledispatchmethod
-59 def fancymethod(self, str_or_int: Union[str, int]):
-60 """A fancy method which is capable of handling either `str` or `int`.
-61
-62 :param str_or_int: string or integer to handle
-63 """
-64 raise NotImplementedError(f"{type(str_or_int)=} not implemented!")
-65
-66 @fancymethod.register
-67 def fancymethod_handle_str(self, str_to_handle: str):
-68 """Fancy method handles a string.
-69
-70 :param str_to_handle: string which will be handled
-71 """
-72 print(f"{type(str_to_handle)} = '{str_to_handle}")
-73
-74 @fancymethod.register
-75 def _fancymethod_handle_int(self, int_to_handle: int):
-76 """Fancy method handles int (not shown in doc).
-77
-78 :param int_to_handle: int which will be handled
-79 """
-80 print(f"{type(int_to_handle)} = '{int_to_handle:x}'")
+ 56class SingleDispatchMethodExample:
+57 @functools.singledispatchmethod
+58 def fancymethod(self, str_or_int: Union[str, int]):
+59 """A fancy method which is capable of handling either `str` or `int`.
+60
+61 :param str_or_int: string or integer to handle
+62 """
+63 raise NotImplementedError(f"{type(str_or_int)=} not implemented!")
+64
+65 @fancymethod.register
+66 def fancymethod_handle_str(self, str_to_handle: str):
+67 """Fancy method handles a string.
+68
+69 :param str_to_handle: string which will be handled
+70 """
+71 print(f"{type(str_to_handle)} = '{str_to_handle}")
+72
+73 @fancymethod.register
+74 def _fancymethod_handle_int(self, int_to_handle: int):
+75 """Fancy method handles int (not shown in doc).
+76
+77 :param int_to_handle: int which will be handled
+78 """
+79 print(f"{type(int_to_handle)} = '{int_to_handle:x}'")
Inherited Members
58 @functools.singledispatchmethod
-59 def fancymethod(self, str_or_int: Union[str, int]):
-60 """A fancy method which is capable of handling either `str` or `int`.
-61
-62 :param str_or_int: string or integer to handle
-63 """
-64 raise NotImplementedError(f"{type(str_or_int)=} not implemented!")
+ 57 @functools.singledispatchmethod
+58 def fancymethod(self, str_or_int: Union[str, int]):
+59 """A fancy method which is capable of handling either `str` or `int`.
+60
+61 :param str_or_int: string or integer to handle
+62 """
+63 raise NotImplementedError(f"{type(str_or_int)=} not implemented!")
Parameters
66 @fancymethod.register
-67 def fancymethod_handle_str(self, str_to_handle: str):
-68 """Fancy method handles a string.
-69
-70 :param str_to_handle: string which will be handled
-71 """
-72 print(f"{type(str_to_handle)} = '{str_to_handle}")
+ 65 @fancymethod.register
+66 def fancymethod_handle_str(self, str_to_handle: str):
+67 """Fancy method handles a string.
+68
+69 :param str_to_handle: string which will be handled
+70 """
+71 print(f"{type(str_to_handle)} = '{str_to_handle}")
7 - `top_level_reimports._internal.baz()`
8"""
9from ._internal import Bar
-10from ._internal import baz
-11from ._internal import Foo
+10from ._internal import Foo
+11from ._internal import baz
12
13__all__ = ["Foo", "Bar", "baz"]