org.python.core

## Class PyType

- java.lang.Object
- - org.python.core.PyObject
  - - org.python.core.PyType

All Implemented Interfaces:
  java.io.Serializable, Traverseproc

Direct Known Subclasses:
  PyJavaType, PyTypeDerived

    public class PyType
    extends PyObject
    implements java.io.Serializable, Traverseproc

This class implements the Python `type` object and the static methods and data structures that support the Python type system in Jython (the type registry).

The class `PyType` contains static data that describes Python types, that are consulted and modified through its static API (notably `fromClass(Class)`). The data structures are guarded against modification by concurrent threads (or consultation while being modified). They support construction of `type` objects that are visible to Python.

Bootstrapping of the type system: The first attempt to construct or get a `PyObject` (or instance of a subclass of `PyObject`), to use the `Py` class utilities, or to call `fromClass(Class)`, causes the Jython type system to be initialised. By the time that call returns, the type system will be in working order: any `PyType`s the application sees will be fully valid. Also, provided that the static initialisation of the `PyObject` subclass in question is not obstructed for any other reason, the instance returned will also be fully functional. Note that it is possible to refer to `C.class`, and (if it is not an exposed type) to produce a `PyType` for it, without causing the static initialisation of `C`.

This may be no less than the reader expected, but we mention it because, for classes encountered during the bootstrapping of the type system, this guarantee is not offered. The (static) initialisation of the type system is highly reentrant. Classes that are used by the type system itself, and their instances, do encounter defective `PyType` objects. Instances of these classes, which include mundane classes like `PyNone` and `PyString`, may exist before their class is statically initialised in the JVM sense. The type system has been implemented with this fact constantly in mind. The `PyType` encountered is always the "right" one — the unique instance representing the Python type of that class — but it may not be completely filled in. Debugging that enters these classes during bootstrapping will take surprising turns. Changes to these classes should also take this into account.

See Also:
  Serialized Form

### Nested Class Summary

### Nested classes/interfaces inherited from class org.python.core.PyObject

`PyObject.ConversionException`

### Field Summary

Fields
`static PyType` `TYPE` The `PyType` of `PyType` (or `type(type)`).

### Fields inherited from class org.python.core.PyObject

`gcMonitorGlobal`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`PyObject` `__call__(PyObject[] args, java.lang.String[] keywords)` The basic method to override when implementing a callable object.
`void` `__delattr__(java.lang.String name)` A variant of the __delattr__ method which accepts a String as the key.
`PyObject` `__findattr_ex__(java.lang.String name)` Attribute lookup hook.
`void` `__setattr__(java.lang.String name, PyObject value)` A variant of the __setattr__ method which accepts a String as the key.
`java.lang.Object` `__tojava__(java.lang.Class<?> c)` Equivalent to the Jython __tojava__ method.
`static void` `addBuilder(java.lang.Class<?> c, org.python.expose.TypeBuilder builder)` Register the `TypeBuilder` for the given class.
`void` `addMethod(PyBuiltinMethod meth)` Adds the given method to this type's dict under its name in its descriptor.
`void` `compatibleForAssignment(PyType other, java.lang.String attribute)` Ensures that the physical layout between this type and `other` are compatible.
`void` `delBases()`
`void` `delDict()`
`void` `delModule()`
`static boolean` `ensureBootstrapped()` Attempt to ensure that the that the type system has fully constructed the types necessary to build a fully-working, exposed, `PyObject` (the "bootstrap types").
`static void` `ensureDoc(PyObject dict)` Ensure dict contains a __doc__.
`static void` `ensureModule(PyObject dict)` Ensure dict contains a __module__, retrieving it from the current frame if it doesn't exist.
`PyObject` `fastGetDict()` Returns the actual dict underlying this type instance.
`java.lang.String` `fastGetName()`
`static PyType` `fromClass(java.lang.Class<?> c)` Look up (create if necessary) the `PyType` for the given target Java class.
`static PyType` `fromClass(java.lang.Class<?> c, boolean hardRef)` Equivalent to `fromClass(Class)`, which is to be preferred.
`PyObject` `getAbstractmethods()`
`PyObject` `getBase()`
`PyObject` `getBases()`
`PyObject` `getDict()` xxx implements where meaningful
`PyObject` `getDoc()` Equivalent of CPython's typeobject.c::type_get_doc; handles __doc__ descriptors.
`PyLong` `getFlags()`
`PyObject` `getModule()`
`PyTuple` `getMro()`
`java.lang.String` `getName()`
`int` `getNumSlots()`
`java.lang.Class<?>` `getProxyType()` Returns the Java Class that this type inherits from, or null if this type is Python-only.
`PyObject` `getStatic()`
`PyObject` `instDict()`
`boolean` `isSubType(PyType supertype)`
`PyObject` `lookup_where(java.lang.String name, PyObject[] where)` Attribute lookup for name through mro objects' dicts.
`PyObject` `lookup(java.lang.String name)` Attribute lookup for name through mro objects' dicts.
`boolean` `needsFinalizer()` Offers public read-only access to the protected field needs_finalizer.
`static PyObject` `newType(PyNewWrapper new_, PyType metatype, java.lang.String name, PyTuple bases, PyObject dict)`
`void` `noAttributeError(java.lang.String name)` Raises AttributeError on type objects.
`void` `pyDelName()`
`PyObject` `pyGetName()`
`void` `pySetName(PyObject name)`
`boolean` `refersDirectlyTo(PyObject ob)` Optional operation.
`void` `removeMethod(PyBuiltinMethod meth)` Removes the given method from this type's dict or raises a KeyError.
`void` `setAbstractmethods(PyObject value)`
`void` `setBases(PyObject newBasesTuple)`
`void` `setDict(PyObject newDict)`
`void` `setName(java.lang.String name)`
`PyObject` `super_lookup(PyType ref, java.lang.String name)`
`java.lang.String` `toString()`
`int` `traverse(Visitproc visit, java.lang.Object arg)` Traverses all directly contained `PyObject`s.
`PyObject` `type___eq__(PyObject other)`
`PyObject` `type___ge__(PyObject other)`
`PyObject` `type___gt__(PyObject other)`
`boolean` `type___instancecheck__(PyObject inst)`
`PyObject` `type___le__(PyObject other)`
`PyObject` `type___lt__(PyObject other)`
`PyObject` `type___ne__(PyObject other)`
`boolean` `type___subclasscheck__(PyObject inst)`
`PyObject` `type___subclasses__()`

### Methods inherited from class org.python.core.PyObject

`__abs__, __add__, __and__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __cmp__, __coerce__, __coerce_ex__, __complex__, __contains__, __delattr__, __delete__, __delitem__, __delitem__, __delslice__, __delslice__, __dir__, __div__, __divmod__, __ensure_finalizer__, __eq__, __findattr__, __findattr__, __finditem__, __finditem__, __finditem__, __float__, __floordiv__, __format__, __ge__, __get__, __getattr__, __getattr__, __getitem__, __getitem__, __getnewargs__, __getslice__, __getslice__, __gt__, __hash__, __hex__, __iadd__, __iand__, __idiv__, __idivmod__, __ifloordiv__, __ilshift__, __imod__, __imul__, __index__, __int__, __invert__, __ior__, __ipow__, __irshift__, __isub__, __iter__, __iternext__, __itruediv__, __ixor__, __le__, __len__, __long__, __lshift__, __lt__, __mod__, __mul__, __ne__, __neg__, __nonzero__, __not__, __oct__, __or__, __pos__, __pow__, __pow__, __radd__, __rand__, __rdiv__, __rdivmod__, __reduce__, __reduce_ex__, __reduce_ex__, __repr__, __rfloordiv__, __rlshift__, __rmod__, __rmul__, __ror__, __rpow__, __rrshift__, __rshift__, __rsub__, __rtruediv__, __rxor__, __set__, __setattr__, __setitem__, __setitem__, __setitem__, __setslice__, __setslice__, __str__, __sub__, __truediv__, __trunc__, __unicode__, __xor__, _add, _and, _callextra, _cmp, _div, _divmod, _doget, _doget, _doset, _eq, _floordiv, _ge, _gt, _iadd, _iand, _idiv, _idivmod, _ifloordiv, _ilshift, _imod, _imul, _in, _ior, _ipow, _irshift, _is, _isnot, _isub, _itruediv, _ixor, _jcall, _jcallexc, _jthrow, _le, _lshift, _lt, _mod, _mul, _ne, _notin, _or, _pow, _rshift, _sub, _truediv, _xor, asDouble, asIndex, asIndex, asInt, asInt, asIterable, asLong, asLong, asName, asName, asString, asString, asStringOrNull, asStringOrNull, bit_length, conjugate, delType, dispatch__init__, equals, fastGetClass, getType, hashCode, implementsDescrDelete, implementsDescrGet, implementsDescrSet, invoke, invoke, invoke, invoke, invoke, invoke, isCallable, isDataDescr, isIndex, isInteger, isMappingType, isNumberType, isSequenceType, object___subclasshook__, readonlyAttributeError, setType`

### Methods inherited from class java.lang.Object

`getClass, notify, notifyAll, wait, wait, wait`

### Field Detail

#### TYPE

    public static final PyType TYPE

The `PyType` of `PyType` (or `type(type)`).

### Method Detail

#### newType

    public static PyObject newType(PyNewWrapper new_,
                                   PyType metatype,
                                   java.lang.String name,
                                   PyTuple bases,
                                   PyObject dict)

#### ensureDoc

    public static void ensureDoc(PyObject dict)

Ensure dict contains a __doc__.

Parameters:
  `dict` - a PyObject mapping

#### ensureModule

    public static void ensureModule(PyObject dict)

Ensure dict contains a __module__, retrieving it from the current frame if it doesn't exist.

Parameters:
  `dict` - a PyObject mapping

#### getStatic

    public PyObject getStatic()

#### needsFinalizer

    public final boolean needsFinalizer()

Offers public read-only access to the protected field needs_finalizer.

Returns:
  a boolean indicating whether the type implements __del__

#### compatibleForAssignment

    public void compatibleForAssignment(PyType other,
                                        java.lang.String attribute)

Ensures that the physical layout between this type and `other` are compatible. Raises a TypeError if not.

#### type___eq__

    public PyObject type___eq__(PyObject other)

#### type___ne__

    public PyObject type___ne__(PyObject other)

#### type___le__

    public PyObject type___le__(PyObject other)

#### type___lt__

    public PyObject type___lt__(PyObject other)

#### type___ge__

    public PyObject type___ge__(PyObject other)

#### type___gt__

    public PyObject type___gt__(PyObject other)

#### getBase

    public PyObject getBase()

#### getBases

    public PyObject getBases()

#### delBases

    public void delBases()

#### setBases

    public void setBases(PyObject newBasesTuple)

#### instDict

    public PyObject instDict()

#### getMro

    public PyTuple getMro()

#### getFlags

    public PyLong getFlags()

#### type___subclasses__

    public final PyObject type___subclasses__()

#### type___subclasscheck__

    public final boolean type___subclasscheck__(PyObject inst)

#### type___instancecheck__

    public final boolean type___instancecheck__(PyObject inst)

#### getProxyType

    public java.lang.Class<?> getProxyType()

Returns the Java Class that this type inherits from, or null if this type is Python-only.

#### isSubType

    public boolean isSubType(PyType supertype)

#### lookup

    public PyObject lookup(java.lang.String name)

Attribute lookup for name through mro objects' dicts. Lookups are cached.

Parameters:
  `name` - attribute name (must be interned)
Returns:
  found object or null

#### lookup_where

    public PyObject lookup_where(java.lang.String name,
                                 PyObject[] where)

Attribute lookup for name through mro objects' dicts. Lookups are cached. Returns where in the mro the attribute was found at where[0].

Parameters:
  `name` - attribute name (must be interned)
  `where` - Where in the mro the attribute was found is written to index 0
Returns:
  found object or null

#### super_lookup

    public PyObject super_lookup(PyType ref,
                                 java.lang.String name)

#### addBuilder

    public static void addBuilder(java.lang.Class<?> c,
                                  org.python.expose.TypeBuilder builder)

Register the `TypeBuilder` for the given class. This only really makes sense for a `PyObject`. Initialising a properly-formed PyObject will usually result in a call to `addBuilder`, thanks to code inserted by the Jython type-exposer.

Parameters:
  `c` - class for which this is the builder
  `builder` - to register

#### ensureBootstrapped

    public static boolean ensureBootstrapped()

Attempt to ensure that the that the type system has fully constructed the types necessary to build a fully-working, exposed, `PyObject` (the "bootstrap types"). Produce a warning message if it does not seem to have worked. This is called at the end of the static initialisation of `PyObject`.

Returns:
  whether bootstrapping was successful

#### fromClass

    public static PyType fromClass(java.lang.Class<?> c,
                                   boolean hardRef)

Equivalent to `fromClass(Class)`, which is to be preferred.

The boolean argument is ignored. Previously it controlled whether the returned `PyType` remained strongly-reachable through a reference the type registry would keep. The returned object is now reachable as long as the class `c` remains loaded.

Parameters:
  `c` - for which the corresponding `PyType` is to be found
  `hardRef` - ignored
Returns:
  the `PyType` found or created

#### fromClass

    public static PyType fromClass(java.lang.Class<?> c)

Look up (create if necessary) the `PyType` for the given target Java class. If the target's `PyType` already exists, this is returned quickly. When a `PyType` must be created, the method updates the registry of type information internal to Jython, caching the answer for next time.

Creating the `PyType` also looks up or creates any `PyType`s that the target depends upon, which results in re-entrant calls to `fromClass` for these classes and (if `PyType`s are created for `PyObject`s) calls to `addBuilder(Class, TypeBuilder)`.

Look-up of existing types is non-blocking in the majority of cases.

Parameters:
  `c` - for which the corresponding `PyType` is to be found
Returns:
  the `PyType` found or created

#### __findattr_ex__

    public PyObject __findattr_ex__(java.lang.String name)

Description copied from class: `PyObject`
Attribute lookup hook. If the attribute is not found, null may be returned or a Py.AttributeError can be thrown, whatever is more correct, efficient and/or convenient for the implementing class. Client code should use `PyObject.__getattr__(String)` or `PyObject.__findattr__(String)`. Both methods have a clear policy for failed lookups.

Overrides:
  `__findattr_ex__` in class `PyObject`
Returns:
  The looked up value. May return null if the attribute is not found

#### __setattr__

    public void __setattr__(java.lang.String name,
                            PyObject value)

Description copied from class: `PyObject`
A variant of the __setattr__ method which accepts a String as the key. This String must be interned.

Overrides:
  `__setattr__` in class `PyObject`
Parameters:
  `name` - the name whose value will be set - must be an interned string .
  `value` - the value to set this name to
See Also:
  `PyObject.__setattr__(PyString, PyObject)`

#### addMethod

    public void addMethod(PyBuiltinMethod meth)

Adds the given method to this type's dict under its name in its descriptor. If there's an existing item in the dict, it's replaced.

#### removeMethod

    public void removeMethod(PyBuiltinMethod meth)

Removes the given method from this type's dict or raises a KeyError.

#### __delattr__

    public void __delattr__(java.lang.String name)

Description copied from class: `PyObject`
A variant of the __delattr__ method which accepts a String as the key. This String must be interned. By default, this will call `__delattr__(PyString name)` with the appropriate args. The only reason to override this method is for performance.

Overrides:
  `__delattr__` in class `PyObject`
Parameters:
  `name` - the name which will be removed - must be an interned string .
See Also:
  `PyObject.__delattr__(PyString)`

#### __call__

    public PyObject __call__(PyObject[] args,
                             java.lang.String[] keywords)

Description copied from class: `PyObject`
The basic method to override when implementing a callable object. The first len(args)-len(keywords) members of args[] are plain arguments. The last len(keywords) arguments are the values of the keyword arguments.

Overrides:
  `__call__` in class `PyObject`
Parameters:
  `args` - all arguments to the function (including keyword arguments).
  `keywords` - the keywords used for all keyword arguments.

#### fastGetName

    public java.lang.String fastGetName()

#### pyGetName

    public PyObject pyGetName()

#### getName

    public java.lang.String getName()

#### pySetName

    public void pySetName(PyObject name)

#### setName

    public void setName(java.lang.String name)

#### pyDelName

    public void pyDelName()

#### fastGetDict

    public PyObject fastGetDict()

Returns the actual dict underlying this type instance. Changes to Java types should go through `addMethod(org.python.core.PyBuiltinMethod)` and `removeMethod(org.python.core.PyBuiltinMethod)`, or unexpected mro errors can occur.

Overrides:
  `fastGetDict` in class `PyObject`
Returns:
  internal object per instance dict or null

#### getDict

    public PyObject getDict()

Description copied from class: `PyObject`
xxx implements where meaningful

Overrides:
  `getDict` in class `PyObject`
Returns:
  internal object __dict__ or null

#### setDict

    public void setDict(PyObject newDict)

Overrides:
  `setDict` in class `PyObject`

#### delDict

    public void delDict()

Overrides:
  `delDict` in class `PyObject`

#### getDoc

    public PyObject getDoc()

Equivalent of CPython's typeobject.c::type_get_doc; handles __doc__ descriptors.

#### __tojava__

    public java.lang.Object __tojava__(java.lang.Class<?> c)

Description copied from class: `PyObject`
Equivalent to the Jython __tojava__ method. Tries to coerce this object to an instance of the requested Java class. Returns the special object `Py.NoConversion` if this `PyObject` can not be converted to the desired Java class.

Overrides:
  `__tojava__` in class `PyObject`
Parameters:
  `c` - the Class to convert this `PyObject` to.

#### getModule

    public PyObject getModule()

#### delModule

    public void delModule()

#### getAbstractmethods

    public PyObject getAbstractmethods()

#### setAbstractmethods

    public void setAbstractmethods(PyObject value)

#### getNumSlots

    public int getNumSlots()

#### toString

    public java.lang.String toString()

Overrides:
  `toString` in class `PyObject`

#### noAttributeError

    public void noAttributeError(java.lang.String name)

Raises AttributeError on type objects. The message differs from PyObject#noAttributeError, to mimic CPython behaviour.

Overrides:
  `noAttributeError` in class `PyObject`

#### traverse

    public int traverse(Visitproc visit,
                        java.lang.Object arg)

Description copied from interface: `Traverseproc`
Traverses all directly contained `PyObject`s. Like in CPython, `arg` must be passed unmodified to `visit` as its second parameter. If `Visitproc.visit(PyObject, Object)` returns nonzero, this return value must be returned immediately by traverse. `Visitproc.visit(PyObject, Object)` must not be called with a `null` PyObject-argument.

Specified by:
  `traverse` in interface `Traverseproc`

#### refersDirectlyTo

    public boolean refersDirectlyTo(PyObject ob)
                             throws java.lang.UnsupportedOperationException

Description copied from interface: `Traverseproc`
Optional operation. Should only be implemented if it is more efficient than calling `Traverseproc.traverse(Visitproc, Object)` with a visitproc that just watches out for `ob`. Must return `false` if `ob` is `null`.

Specified by:
  `refersDirectlyTo` in interface `Traverseproc`
Throws:
  `java.lang.UnsupportedOperationException`