All Classes and Interfaces

Class
Description
Abstract class that manages bulk structural and data operations on arrays, defering type-specific element-wise operations to the subclass.
 
 
Base class for weakref types.
 
This class reads a classfile from a byte array and pulls out the value of the class annotation for APIVersion, which can then be retrieved by a call to getVersion().
A utility class for handling mixed positional and keyword arguments.
 
The python array module, plus jython extensions from jarray.
 
Base implementation of the Buffer API appropriate to 1-dimensional arrays, of any item size, independent of the storage implementation.
Base implementation of the Buffer API for when the storage implementation is byte[].
Base implementation of the Buffer API providing variables and accessors for the navigation arrays, methods for expressing and checking the buffer request flags, methods and mechanism for get-release counting, boilerplate error checks and their associated exceptions, and default implementations of some methods for access to the buffer content.
Base class for Jython bytearray (and bytes in due course) that provides most of the Java API, including Java List behaviour.
 
Base implementation of the Buffer API for when the storage implementation is java.nio.ByteBuffer.
 
 
A Buffered text stream in binary mode.
The binascii.java module contains a number of methods to convert between binary and various ASCII-encoded binary representations.
Base class for buffered I/O objects.
A mixin implementation of BufferedIOBase with an underlying raw stream.
A buffered reader and writer together for a random access file.
Buffer for a readable sequential RawIO object.
Buffer for a writable sequential RawIO object.
Interface marking an object as capable of exposing its internal state as a PyBuffer.
 
 
Utility class for loading compiled Python modules and Java classes defined in Python modules.
 
Notifies registered callbacks if new bytecode is loaded.
Interface for callbacks.
Simple class that provides the capability to swap or reverse the byte order of all elements of an Array.
Python bz2 module
Abstract package manager that gathers info about statically known classes from a set of jars and the Java runtime.
Class of object used to represent a cache file and last modification time, internally and to CachedJarsPackageManager.outCreateCacheFile(org.python.core.packagecache.CachedJarsPackageManager.JarXEntry, boolean).
ProxyType with __call__.
 
Emulates the Python (ie POSIX) 'C' locale.
 
 
 
An empty tagging interface that can be used if a java class want control over the class dict initialization.
Implements the algorithm originally used in Py.java2py(java.lang.Object) to adapt objects.
 
 
 
 
This class implements the codec registry and utility methods supporting codecs, such as those providing the standard replacement strategies ("ignore", "backslashreplace", etc.).
 
Represents flags that can be set on code objects.
 
 
 
Collections - This module adds the ability to use high performance data structures
 
 
 
 
 
Facade for different compiler implementations.
 
 
 
 
A class named in configuration as the value of python.console must implement this interface, and provide a constructor with a single String argument, to be acceptable during initialization of the interpreter.
This class is intended to replace System.in for use with console libraries that provide a line-oriented input mechanism.
Enumeration used to specify whether an end-of-line should be added or replaced at the end of each line read.
This class may be used to wrap and replace System.out so that the console handling library (JLine or Java Readline) can treat an incomplete line (one without a newline) as a prompt string, and so know the true position of the cursor.
Jython stores Python-Bytecode of methods and functions that exceed JVM method-size restrictions in String literals.
Straightens the call path for some common cases
A PyObject that provides __enter__ and __exit__ methods for use in the with-statement.
 
 
From the python documentation:
The Pickler object
The Unpickler object.
This module implements a file-like class, StringIO, that reads and writes a string buffer (also known as memory files).
The StringIO object
 
 
 
Raw I/O implementation for datagram sockets.
The DataHandler is responsible mapping the JDBC data type to a Jython object.
Provide an extensible way to create dates for zxJDBC.
Separating these largely constant values from Python encoding conversions allows for safer initialization even if modules are loaded in different orders.
Date related string values.
This class wraps the types from java.sql.Type in order for PyCursor to differentiate between a regular PyInteger and a SQL datatype value.
Derived classes utility methods.
 
 
 
 
 
 
 
 
 
 
The Python errno module.
The builtin exceptions module.
A PyObjectAdapter attempts to adapt a Java Object with three user fillable groups of adapters: preClass, class and postClass.
A static utility class with two additional math functions.
The responsibility of a Fetch instance is to manage the iteration of a ResultSet.
This class is an implementation of the iterator object returned by str.
 
Jython file descriptor management.
Raw I/O implementation for OS files.
 
Utility methods for Java file handling.
A FilterDataHandler contains some other DataHandler, which it uses as its basic source of functionality, possibly transforming the calls along the way or providing additional functionality.
See documentation of FinalizablePyObject.
This interface allows PyObjects to have finalizers.
This interface should never be used directly in any hand-written code (except in FinalizeTrigger.java).
To use finalizers on PyObjects, read the documentation of FinalizablePyObject.
Reserved for use by JyNI.
A class that provides the implementation of floating-point formatting.
 
 
 
In Jython, the gc module notably differs from that in CPython.
 
Static methods to make instances of collections with their generic types inferred from what they're being assigned to.
 
 
 
 
 
 
 
 
 
 
 
 
 
Utility functions for "import" support.
A bundle of a file name, the file's content and a last modified time, with no behaviour.
A base class for PEP-302 path hooks.
Deprecated.
This class is deprecated.
A class that provides the implementation of integer formatting.
A minor variation on IntegerFormatter to handle "traditional" %-formatting.
This class provides the read, execute, print loop needed by a Python console; it is not actually a console itself.
This class provides the interface for compiling and running code that supports an interactive interpreter.
 
A class that provides the base for implementations of type-specific formatting.
Parsed PEP-3101 format specification of a single field, encapsulating the format for use by formatting methods.
An implementation of Memory that throws an exception on any access.
 
Base class for all I/O classes.
 
 
Functional tools for creating and using iterators.
 
 
 
 
 
JarRunner initializes sys (PySystemState), passing args in (including the name "__run__" as arg 0 for consistancy with Python expectations), and import __run__.
Produce java.
Load Java classes.
Helper class handling the VM specific java package detection.
 
Support for JDBC 2.x type mappings, including Arrays, CLOBs and BLOBs.
Support for JDBC 3.x additions, notably ParameterMetaData.
 
 
 
 
 
 
 
 
 
 
 
 
This class uses JLine to provide readline like functionality to its console without requiring native readline support.
Manages a linked list of general purpose Object-attributes that can be attached to arbitrary PyObjects.
Compiles all python files in a directory to bytecode, and writes them to another directory, possibly the same one.
Sources locale information from standard Java API functions, such as that in Locale and DecimalFormat.
 
A copy of the DataHandler class as it was before Jython 2.5.
Jythonc is a Python compiler into Java Bytecode.
A service for initializing Jython without explicitly calling PySystemState.initialize().
Not for application use, a cache of recently given results from some costly function.
A line buffered writer and a non buffered reader together for a random access file.
Line buffering for a writable sequential RawIO object.
 
Provides an implementation of the object that str.
 
 
 
 
 
Abstracted memory operations.
 
Unions several resource collections by the name of their contained resources.
 
 
This class contains stuff that almost exists in the library already, but with interfaces that I found more suitable.
An implementation of MemoryIO that throws an exception on any access.
 
An object able to check a file access mode provided as a String and represent it as boolean attributes and in a normalised form.
 
A class with static fields for each of the settable options.
Abstract package manager.
Facade for the classes in the org.python.antlr package.
Path package manager.
 
 
 
A base class for classes that can install a console wrapper for a specific console-handling library.
Methods for testing the platform/operating system that we are on.
 
 
The posix/nt module, depending on the platform.
 
 
 
 
This class is part of the Jython run-time system, and contains only "pre-Python" data and methods that may safely be used before the type system is ready.
This class provides the necessary functionality to call stored procedures.
 
 
 
A weak reference proxy object.
 
Implementation of the Python buffer type.
The type array.array.
 
 
The base class for all standard Python exceptions.
 
base class for jython strings.
 
 
 
The builtin python bool.
This interface provides a base for the key interface of the buffer API, PyBuffer, including symbolic constants used by the consumer of a PyBuffer to specify its requirements and assumptions.
The Jython buffer API for access to a byte array within an exporting object.
Deprecated.
 
 
 
A builtin classmethod with a restricted number of arguments.
 
 
A helper class for faster implementations of commonly called methods.
 
 
 
Implementation of Python bytearray with a Java API that includes equivalents to most of the Python API.
 
 
 
 
 
 
 
 
 
The Python cell type.
The classic Python class.
The classmethod descriptor.
 
 
A super class for all python code implementations.
A builtin python complex number
 
 
A connection to the database.
These objects represent a database cursor, which is used to manage the context of a fetch operation.
Implements type checking and return type coercion for a data descriptor.
PyDefaultDict - This is a subclass of the builtin dict(PyDictionary) class.
 
PyDeque - This class implements the functionalities of Deque data structure.
 
 
The Python CSV Dialect type.
 
A builtin python dictionary.
 
Readonly proxy for dictionaries (actually any mapping).
A class representing the singleton Ellipsis ... object.
The Python builtin enumerate type.
 
A wrapper for all python exception.
A cursor with extensions to the DB API 2.0.
Sequence iterator specialized for accessing the underlying sequence directly.
The Python file type.
 
 
 
 
 
Enables you to write Jython modules that inherit from javax.servlet.Filter, and to insert them in your servlet container's filter chain, like any Java Filter.
A builtin python float.
 
 
A Python frame object.
 
 
A Python function.
An entry point for class that implements several function calls.
 
A tagging exception.
A convenience class for creating Indentation errors.
An instance of a classic Python class.
A builtin python int.
 
The Python module _io.
 
PyIOFiles encapsulates and optimise access to the different file representation.
 
An abstract helper class useful when implementing an iterator object.
A representation of java package.
 
 
 
 
 
 
Definition of a Python native locale implementation.
 
A builtin python long.
 
Class implementing the Python memoryview type.
A Python method.
 
The Python Module object.
 
 
The singleton None object.
 
 
All objects known to the Jython runtime system are represented by an instance of the class PyObject or one of its subclasses.
 
PyObjectAdapters turn Java Objects into PyObjects.
 
A __new__ function that tells its subclasses to just init if __new__ is being called on the type the function was defined on.
 
 
 
 
Common methods for all generated proxy classes.
 
 
An implementation of Python _io.
 
CSV file reader.
 
 
 
An iterator that yields the objects from a sequence-like object in reverse order.
Interface implemented by compiled modules which allow access to to the module code object.
 
The abstract superclass of PyObjects that implements a Sequence.
General sequence iterator.
 
This servlet is used to re-serve Jython servlets.
Initializes the jython runtime inside a servlet engine.
 
 
This class provides a string that sometimes seems to change value, as far as equality tests and startswith are concerned.
 
 
The Python slice object.
 
Class PyStatement
The staticmethod descriptor.
 
A builtin python string.
 
Special fast dict implementation for __dict__ instances.
 
 
The Python super type.
 
A convenience class for creating Syntax errors.
The "sys" module.
 
A weak reference that allows to keep track of PySystemState within Jython core runtime without leaking: as soon as it gets garbage collected, we can clear the places where we have associated data stored.
An implementation of PyCode where the actual executable content is stored as a PyFunctionTable instance and an integer index.
 
 
 
 
The PythonInterpreter class is a standard wrapper for a Jython interpreter for embedding in a Java application.
 
Jython specific hooks for our underlying POSIX library.
struct_time of the time module.
A python traceback object.
A builtin python tuple.
 
 
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).
 
a builtin python unicode string.
 
 
CSV file writer.
The builtin xrange type.
Specially optimized xrange iterator.
CSV quoting styles.
 
Base class for raw binary I/O.
 
Reserved for use by JyNI.
 
 
Map the signature of a method to the Method itself, within the context of a given simple name.
Supported registry keys and their usage.
A java.io.File whose initial path is resolved relative to the current SystemState's current working directory.
 
 
 
 
 
 
 
Handles all the index checking and manipulation for get, set and del operations on a sequence.
Raw I/O implementation for server sockets.
 
 
Deprecated.
use the SHA224 implementation provided in Java 8 and later
Buffer API over a read-only one-dimensional array of one-byte items.
Buffer API over a read-only one-dimensional java.nio.ByteBuffer of one-byte items.
Buffer API that appears to be a one-dimensional array of one-byte items providing read-only API, but which is actually backed by a Java String.
Buffer API over a writable one-dimensional array of one-byte items.
 
 
Raw I/O implementation for sockets.
Base raw I/O implementation for sockets.
 
 
 
 
 
 
Raw I/O implementation for simple streams.
Read-only buffer API over a one-dimensional array of one-byte items, that are evenly-spaced in a storage array.
Read-only buffer API over a one-dimensional java.nio.ByteBuffer of one-byte items, that are evenly-spaced in that store.
Read-write buffer API over a one-dimensional array of one-byte items, that are evenly-spaced in a storage array.
 
Not for application use, this class may be used to count how many times a String occurs a point in the runtime.
String Utility methods.
This module performs conversions between Python values and C structs represented as Python strings.
 
 
 
 
 
 
System package manager.
 
 
 
 
Template is an Ant task for generating new-style object definitions based on template files.
A class that provides the implementation of str and unicode formatting.
Base class for text I/O.
An InputStream tie-in to a TextIOBase.
A Buffered text stream.
 
 
 
 
This interface defines a CPython-equivalent traverse-mechanism allowing to detect reference cycles.
This is used like Traverseproc, but traverses only the slots[]-array of fooDerived-classes.
 
 
A Buffered text stream in universal newlines mode.
Indicates that a given class is not traversable and does intentionally not implement Traverseproc.
 
An event signalling the a SQLWarning was encountered while building results from a ResultSet.
 
The _weakref module.
Exposes a Python iter as a Java Iterator.
Buffer API over a zero length, one-dimensional array of one-byte items.
This module adds the ability to import Python modules (*.py, *$py.class) and packages from ZIP-format archives.
Import Python modules and packages from ZIP-format archives.
 
Creates database connections.
The builtin module.
BytecodeTools provides tools for generated JVM bytecode.
This class corresponds to the Python _codecs module, which in turn lends its functions to the codecs module (in Lib/codecs.py).
Optimized charmap encoder mapping.
The Python _csv module.
The Python _functools module.
The Python _hashlib module: provides hashing algorithms via java.security.MessageDigest.
A generic wrapper around a MessageDigest.
 
This module is a nearly exact line by line port of _json.c to Java.
The Python _io module implemented in Java.
 
Java native implementation of underlying locale functions, fitting the interface defined or implied by the Python locale module.