Provide default value for the annotated parameter. This is equivalent to following it with "=" in a Python signature. Allowed values are a small subset of the Python literals, presented as a String: "None", an integer, or a single-quoted string. For example

 PyList split(
     @Default("None") Object sep,
     @Default("-1") int maxsplit
 )

Identify a method as that to be called during a Python call to __delattr__ naming an exposed attribute.

The signature must be ()V.

Specify the documentation string (__doc__) for a method, field, etc. defined in Java and exposed to Python.

Documentation-only annotation reminding us that the defining class guarantees not to change the contents. If a new value is assigned, it will be a new array. It is therefore safe to take a reference to this array and treat it as frozen (e.g. to expose it as a tuple). There is no enforcement of this contract at run time.

Identify a method as that to be called during a Python call to __getattribute__ naming an exposed attribute.

The signature must be ()T where T can be Object if the implementor has no reason to do otherwise. (One reason might be type safety when calling the same method from Java.) The annotated method is responsible for converting to T from however the attribute is represented internally to the type.

Declare that the annotated parameter is the collector for excess keyword arguments. This is equivalent to preceding the name with "**" in a Python signature. The type must be PyDict.

Declare that the annotated parameter is the first keyword only parameter. This is equivalent to preceding it with "*, " in a Python signature.

Identify a field of a Python object as an exposed attribute. Get, set and delete operations are provided automatically on a descriptor that will be entered in the dictionary of the type being defined. If the field is Java final it will be read-only.

Some primitive types and String receive special support for conversion from Python objects. A field of type Object may easily be made a member and will then receive any Python object.

The annotated field may have any Java reference type. In that case, an attempt to assign a Python object of the wrong Java type will raise a TypeError. This makes it possible to declare an attribute of a specific Python type. For example one enforce tuple values by declaring the field as a PyTuple. The field would also accept Python sub-classes of the attribute type, since they must be sub-classes in Java too.

This approach creates a limitation where the corresponding Python type has multiple Java implementations not related by Java inheritance and is not specially provided for (like String). The set operation of the Member attribute will reject instances that have the intended Python type but non-matching Java type (with a confusing TypeError to boot). A writable attribute of that type should be implemented as Object or using explicit Getter, Setter and Deleter methods.

Override the name of an parameter to a method defined in Java, as it will appear to Python (in generated signatures and error messages). It is preferable to use a name in Java that conventional for Python, and is only necessary to annotate one when the conventional name is impossible (e.g. "new").

Declare that the annotated parameter is the collector for excess positional arguments. This is equivalent to preceding the name with "*" in a Python signature. The type must be PyTuple.

Declare that the annotated parameter is the last positional only parameter. This is equivalent to following it with ", /" in a Python signature.

Identify a Python instance method of a type or module defined in Java and exposed to Python. The signature must be a supported type for which coercions can be found for its parameters.

When found in the classes that define a built-in type, this annotation results in a method definition, then a descriptor in the dictionary of the type. When found in the class that defines a built-in module, this annotation results in a method definition in the module specification, and a bound method in the dictionary of each module instance created from it.

Annotations may appear on the parameters of a method annotated with PythonMethod. These further describe the method, defining the parameters as positional-only parameters, or providing default values. A method may also be annotated with a documentation string (in the Python sense), by means of the @DocString annotation.

In types that accept multiple implementations, more than one method of the same name may be annotated PythonMethod. Only one may be the primary definition (see PythonMethod#primary(), and only in that one are the documentation string and parameter annotations effective. (It need not be the first definition.) These annotations on the primary definition define the signature that Python sees.

def g(a, b, c):
    print(a, b, c)

>>> g(b=2, c=3, a=1)
1 2 3
>>> g(**dict(b=2, c=3, a=1))
1 2 3

Identify a Python static method of a type or module defined in Java and exposed to Python. The signature must be a supported type for which coercions can be found for its parameters.

When found in the classes that define a built-in type, this annotation results in a method definition, then a staticmethod object in the dictionary of the type. When found in the class that defines a built-in module, this annotation results in a method definition in the module specification, and an unbound method in the dictionary of each module instance created from it.

Annotations may appear on the parameters of a method annotated with PythonStaticMethod. These further describe the method, defining the parameters as positional-only parameters, or providing default values. A method may also be annotated with a documentation string (in the Python sense), by means of the @DocString annotation.

Only one method of the given name, in a given class class, may be annotated as a PythonStaticMethod.

def g(a, b, c):
    print(a, b, c)

>>> g(b=2, c=3, a=1)
1 2 3
>>> g(**dict(b=2, c=3, a=1))
1 2 3

Identify a method as that to be called during a Python call to __setattr__ naming an exposed attribute.

The signature must be (T)V where T is often Object. The annotated method is responsible for converting this to the form in which the attribute is represented internally to the type. If Tis something more specific than Object, a cast occurs to this Java type during the descriptor call, which if it fails will raise a Python TypeError.