Run of fresh-snapshots for python-funcsigs

Try this locally (using silver-platter):

debian-svp new-upstream --snapshot python-funcsigs 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
[2021-04-05 03:10:09] Running ['new-upstream', '--snapshot']
[2021-04-05 03:10:09] Opening branch at https://salsa.debian.org/openstack-team/python/python-funcsigs.git/,branch=debian%2Fussuri
[2021-04-05 03:10:11] Using cached branch https://janitor.debian.net/git/python-funcsigs/,branch=debian%2Flatest
[2021-04-05 03:10:13] Total 526 (delta 0), reused 0 (delta 0), pack-reused 526
[2021-04-05 03:10:15] Total 7 (delta 0), reused 6 (delta 0), pack-reused 0
[2021-04-05 03:10:15] Workspace ready - starting.
<string>:73: (INFO/1) No role entry for "func" in module "docutils.parsers.rst.languages.en".
Trying "func" as canonical role name.
<string>:73: (ERROR/3) Unknown interpreted text role "func".
<string>:77: (INFO/1) No directive entry for "function" in module "docutils.parsers.rst.languages.en".
Trying "function" as canonical directive name.
<string>:77: (ERROR/3) Unknown directive type "function".

.. function:: signature(callable)

   Return a :class:`Signature` object for the given ``callable``::

      >>> from funcsigs import signature
      >>> def foo(a, *, b:int, **kwargs):
      ...     pass

      >>> sig = signature(foo)

      >>> str(sig)
      '(a, *, b:int, **kwargs)'

      >>> str(sig.parameters['b'])
      'b:int'

      >>> sig.parameters['b'].annotation
      <class 'int'>

   Accepts a wide range of python callables, from plain functions and classes to
   :func:`functools.partial` objects.

   .. note::

      Some callables may not be introspectable in certain implementations of
      Python.  For example, in CPython, built-in functions defined in C provide
      no metadata about their arguments.


<string>:108: (INFO/1) No role entry for "class" in module "docutils.parsers.rst.languages.en".
Trying "class" as canonical role name.
<string>:108: (ERROR/3) Unknown interpreted text role "class".
<string>:108: (INFO/1) No role entry for "attr" in module "docutils.parsers.rst.languages.en".
Trying "attr" as canonical role name.
<string>:108: (ERROR/3) Unknown interpreted text role "attr".
<string>:112: (INFO/1) No role entry for "meth" in module "docutils.parsers.rst.languages.en".
Trying "meth" as canonical role name.
<string>:112: (ERROR/3) Unknown interpreted text role "meth".
<string>:115: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:115: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Signature.empty

   A special class-level marker to specify absence of a return annotation.

<string>:119: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:119: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Signature.parameters

   An ordered mapping of parameters' names to the corresponding
   :class:`Parameter` objects.

<string>:124: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:124: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Signature.return_annotation

   The "return" annotation for the callable.  If the callable has no "return"
   annotation, this attribute is set to :attr:`Signature.empty`.

<string>:129: (INFO/1) No directive entry for "method" in module "docutils.parsers.rst.languages.en".
Trying "method" as canonical directive name.
<string>:129: (ERROR/3) Unknown directive type "method".

.. method:: Signature.bind(*args, **kwargs)

   Create a mapping from positional and keyword arguments to parameters.
   Returns :class:`BoundArguments` if ``*args`` and ``**kwargs`` match the
   signature, or raises a :exc:`TypeError`.

<string>:135: (INFO/1) No directive entry for "method" in module "docutils.parsers.rst.languages.en".
Trying "method" as canonical directive name.
<string>:135: (ERROR/3) Unknown directive type "method".

.. method:: Signature.bind_partial(*args, **kwargs)

   Works the same way as :meth:`Signature.bind`, but allows the omission of
   some required arguments (mimics :func:`functools.partial` behavior.)
   Returns :class:`BoundArguments`, or raises a :exc:`TypeError` if the
   passed arguments do not match the signature.

<string>:142: (INFO/1) No directive entry for "method" in module "docutils.parsers.rst.languages.en".
Trying "method" as canonical directive name.
<string>:142: (ERROR/3) Unknown directive type "method".

.. method:: Signature.replace(*[, parameters][, return_annotation])

   Create a new Signature instance based on the instance replace was invoked
   on.  It is possible to pass different ``parameters`` and/or
   ``return_annotation`` to override the corresponding properties of the base
   signature.  To remove return_annotation from the copied Signature, pass in
   :attr:`Signature.empty`.

   ::

      >>> def test(a, b):
      ...     pass
      >>> sig = signature(test)
      >>> new_sig = sig.replace(return_annotation="new return anno")
      >>> str(new_sig)
      "(a, b) -> 'new return anno'"
<string>:162: (INFO/1) No role entry for "meth" in module "docutils.parsers.rst.languages.en".
Trying "meth" as canonical role name.
<string>:162: (ERROR/3) Unknown interpreted text role "meth".
<string>:165: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:165: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Parameter.empty

   A special class-level marker to specify absence of default values and
   annotations.

<string>:170: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:170: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Parameter.name

   The name of the parameter as a string.  Must be a valid python identifier
   name (with the exception of ``POSITIONAL_ONLY`` parameters, which can have
   it set to ``None``).

<string>:176: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:176: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Parameter.default

   The default value for the parameter.  If the parameter has no default
   value, this attribute is set to :attr:`Parameter.empty`.

<string>:181: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:181: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Parameter.annotation

   The annotation for the parameter.  If the parameter has no annotation,
   this attribute is set to :attr:`Parameter.empty`.

<string>:186: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:186: (ERROR/3) Unknown directive type "attribute".

.. attribute:: Parameter.kind

   Describes how argument values are bound to the parameter.  Possible values
   (accessible via :class:`Parameter`, like ``Parameter.KEYWORD_ONLY``):

   +------------------------+----------------------------------------------+
   |    Name                | Meaning                                      |
   +========================+==============================================+
   | *POSITIONAL_ONLY*      | Value must be supplied as a positional       |
   |                        | argument.                                    |
   |                        |                                              |
   |                        | Python has no explicit syntax for defining   |
   |                        | positional-only parameters, but many built-in|
   |                        | and extension module functions (especially   |
   |                        | those that accept only one or two parameters)|
   |                        | accept them.                                 |
   +------------------------+----------------------------------------------+
   | *POSITIONAL_OR_KEYWORD*| Value may be supplied as either a keyword or |
   |                        | positional argument (this is the standard    |
   |                        | binding behaviour for functions implemented  |
   |                        | in Python.)                                  |
   +------------------------+----------------------------------------------+
   | *VAR_POSITIONAL*       | A tuple of positional arguments that aren't  |
   |                        | bound to any other parameter. This           |
   |                        | corresponds to a ``*args`` parameter in a    |
   |                        | Python function definition.                  |
   +------------------------+----------------------------------------------+
   | *KEYWORD_ONLY*         | Value must be supplied as a keyword argument.|
   |                        | Keyword only parameters are those which      |
   |                        | appear after a ``*`` or ``*args`` entry in a |
   |                        | Python function definition.                  |
   +------------------------+----------------------------------------------+
   | *VAR_KEYWORD*          | A dict of keyword arguments that aren't bound|
   |                        | to any other parameter. This corresponds to a|
   |                        | ``**kwargs`` parameter in a Python function  |
   |                        | definition.                                  |
   +------------------------+----------------------------------------------+

   Example: print all keyword-only arguments without default values::

      >>> def foo(a, b, *, c, d=10):
      ...     pass

      >>> sig = signature(foo)
      >>> for param in sig.parameters.values():
      ...     if (param.kind == param.KEYWORD_ONLY and
      ...                        param.default is param.empty):
      ...         print('Parameter:', param)
      Parameter: c

<string>:236: (INFO/1) No directive entry for "method" in module "docutils.parsers.rst.languages.en".
Trying "method" as canonical directive name.
<string>:236: (ERROR/3) Unknown directive type "method".

.. method:: Parameter.replace(*[, name][, kind][, default][, annotation])

   Create a new Parameter instance based on the instance replaced was invoked
   on.  To override a :class:`Parameter` attribute, pass the corresponding
   argument.  To remove a default value or/and an annotation from a
   Parameter, pass :attr:`Parameter.empty`.

   ::

      >>> from funcsigs import Parameter
      >>> param = Parameter('foo', Parameter.KEYWORD_ONLY, default=42)
      >>> str(param)
      'foo=42'

      >>> str(param.replace()) # Will create a shallow copy of 'param'
      'foo=42'

      >>> str(param.replace(default=Parameter.empty, annotation='spam'))
      "foo:'spam'"
<string>:259: (INFO/1) No role entry for "meth" in module "docutils.parsers.rst.languages.en".
Trying "meth" as canonical role name.
<string>:259: (ERROR/3) Unknown interpreted text role "meth".
<string>:259: (INFO/1) No role entry for "meth" in module "docutils.parsers.rst.languages.en".
Trying "meth" as canonical role name.
<string>:259: (ERROR/3) Unknown interpreted text role "meth".
<string>:262: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:262: (ERROR/3) Unknown directive type "attribute".

.. attribute:: BoundArguments.arguments

   An ordered, mutable mapping (:class:`collections.OrderedDict`) of
   parameters' names to arguments' values.  Contains only explicitly bound
   arguments.  Changes in :attr:`arguments` will reflect in :attr:`args` and
   :attr:`kwargs`.

   Should be used in conjunction with :attr:`Signature.parameters` for any
   argument processing purposes.

   .. note::

      Arguments for which :meth:`Signature.bind` or
      :meth:`Signature.bind_partial` relied on a default value are skipped.
      However, if needed, it is easy to include them.

   ::

     >>> def foo(a, b=10):
     ...     pass

     >>> sig = signature(foo)
     >>> ba = sig.bind(5)

     >>> ba.args, ba.kwargs
     ((5,), {})

     >>> for param in sig.parameters.values():
     ...     if param.name not in ba.arguments:
     ...         ba.arguments[param.name] = param.default

     >>> ba.args, ba.kwargs
     ((5, 10), {})


<string>:297: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:297: (ERROR/3) Unknown directive type "attribute".

.. attribute:: BoundArguments.args

   A tuple of positional arguments values.  Dynamically computed from the
   :attr:`arguments` attribute.

<string>:302: (INFO/1) No directive entry for "attribute" in module "docutils.parsers.rst.languages.en".
Trying "attribute" as canonical directive name.
<string>:302: (ERROR/3) Unknown directive type "attribute".

.. attribute:: BoundArguments.kwargs

   A dict of keyword arguments values.  Dynamically computed from the
   :attr:`arguments` attribute.

<string>:307: (INFO/1) No role entry for "attr" in module "docutils.parsers.rst.languages.en".
Trying "attr" as canonical role name.
<string>:307: (ERROR/3) Unknown interpreted text role "attr".
<string>:307: (INFO/1) No role entry for "attr" in module "docutils.parsers.rst.languages.en".
Trying "attr" as canonical role name.
<string>:307: (ERROR/3) Unknown interpreted text role "attr".
<string>:318: (INFO/1) No directive entry for "seealso" in module "docutils.parsers.rst.languages.en".
Trying "seealso" as canonical directive name.
<string>:318: (ERROR/3) Unknown directive type "seealso".

.. seealso::

   :pep:`362` - Function Signature Object.
      The detailed specification, implementation details and examples.

<string>:334: (INFO/1) Duplicate explicit target name: "psf license agreement".
<string>:336: (INFO/1) Hyperlink target "read the docs" is not referenced.
[2021-04-05 03:10:16] http://funcsigs.readthedocs.org/ is permanently redirected to http://funcsigs.readthedocs.io/
[2021-04-05 03:10:16] http://funcsigs.readthedocs.io/ is redirected to https://funcsigs.readthedocs.io/
[2021-04-05 03:10:19] https://funcsigs.readthedocs.io/ is redirected to https://funcsigs.readthedocs.io/en/0.4/
[2021-04-05 03:10:25] http://funcsigs.readthedocs.org/ is permanently redirected to http://funcsigs.readthedocs.io/
[2021-04-05 03:10:25] http://funcsigs.readthedocs.io/ is redirected to https://funcsigs.readthedocs.io/
[2021-04-05 03:10:26] https://funcsigs.readthedocs.io/ is redirected to https://funcsigs.readthedocs.io/en/0.4/
[2021-04-05 03:10:27] Using upstream branch https://github.com/testing-cabal/funcsigs.git (guessed)
[2021-04-05 03:10:28] Total 34 (delta 14), reused 14 (delta 14), pack-reused 19
[2021-04-05 03:10:28] Using version string 1.0.2+git20210309.1.82a2d85.
[2021-04-05 03:10:28] No upstream upstream-revision format specified, trying tag:1.0.2
[2021-04-05 03:10:28] Including upstream history, since previous upstream version (1.0.2) is present in packaging branch history.
[2021-04-05 03:10:28] Looking for upstream python-funcsigs/1.0.2+git20210309.1.82a2d85 in upstream branch <RemoteGitBranch('https://github.com/testing-cabal/funcsigs.git/', 'master')>.
[2021-04-05 03:10:49] Searching for revision importing python-funcsigs version 1.0.2 on packaging branch, tag debian/1.0.2-1, tag debian/1.0.2-5, tag debian/1.0.2-4.

Full worker log Full dist log