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().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.A wrapper class around native java arrays.
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.
SHA-224 as described in RFC 3874.
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.
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.
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.