Incorrect errors logged by the positional_decorator

[hiranya911]

Calling http.BatchHttpRequest() with only positional arguments raises/logs the following error:

req = BatchHttpRequest(callback, my_batch_uri)

TypeError: __init__() takes at most 1 positional argument (3 given)

This makes no sense since I'm only passing 2 arguments to the constructor.

Moreover, the decorator on the constructor indicates positional(1), which I assume means should allow at most one positional argument. But the following doesn't work:

req = BatchHttpRequest(callback, batch_uri=my_batch_uri)

TypeError: __init__() takes at most 1 positional argument (2 given)

[busunkim96]

It looks like that decorator was written to force arguments to be passed by name. The number '1' in positional(1) means 'allow 1 positional argument'. In this case the one allowed positional argument is self. Everything after it must be passed as a keyword.

google-api-python-client/googleapiclient/_helpers.py

Lines 42 to 110 in 66bb32c

	def positional(max_positional_args):
	"""A decorator to declare that only the first N arguments my be positional.
	This decorator makes it easy to support Python 3 style keyword-only
	parameters. For example, in Python 3 it is possible to write::
	def fn(pos1, *, kwonly1=None, kwonly1=None):
	...
	All named parameters after ``*`` must be a keyword::
	fn(10, 'kw1', 'kw2') # Raises exception.
	fn(10, kwonly1='kw1') # Ok.
	Example
	^^^^^^^
	To define a function like above, do::
	@positional(1)
	def fn(pos1, kwonly1=None, kwonly2=None):
	...
	If no default value is provided to a keyword argument, it becomes a
	required keyword argument::
	@positional(0)
	def fn(required_kw):
	...
	This must be called with the keyword parameter::
	fn() # Raises exception.
	fn(10) # Raises exception.
	fn(required_kw=10) # Ok.
	When defining instance or class methods always remember to account for
	``self`` and ``cls``::
	class MyClass(object):
	@positional(2)
	def my_method(self, pos1, kwonly1=None):
	...
	@classmethod
	@positional(2)
	def my_method(cls, pos1, kwonly1=None):
	...
	The positional decorator behavior is controlled by
	``_helpers.positional_parameters_enforcement``, which may be set to
	``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or
	``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do
	nothing, respectively, if a declaration is violated.
	Args:
	max_positional_arguments: Maximum number of positional arguments. All
	parameters after the this index must be
	keyword only.
	Returns:
	A decorator that prevents using arguments after max_positional_args
	from being used as positional parameters.
	Raises:
	TypeError: if a key-word only argument is provided as a positional
	parameter, but only if
	_helpers.positional_parameters_enforcement is set to

Closing as this works as intended.