py

type BigInt ¶

type BigInt big.Int

func BigIntCheck(obj Object) (*BigInt, error)

func BigIntCheckExact(obj Object) (*BigInt, error)

func ConvertToBigInt(other Object) (*BigInt, bool)

func (a *BigInt) Float() (Float, error)

func (a *BigInt) Frexp() (frac float64, exp int)

func (x *BigInt) GoInt() (int, error)

func (x *BigInt) GoInt64() (int64, error)

func (x *BigInt) Int() (Int, error)

func (a *BigInt) M__abs__() (Object, error)

func (a *BigInt) M__add__(other Object) (Object, error)

func (a *BigInt) M__and__(other Object) (Object, error)

func (a *BigInt) M__bool__() (Object, error)

func (a *BigInt) M__ceil__() (Object, error)

func (a *BigInt) M__complex__() (Object, error)

func (a *BigInt) M__divmod__(other Object) (Object, Object, error)

func (a *BigInt) M__eq__(other Object) (Object, error)

func (a *BigInt) M__float__() (Object, error)

func (a *BigInt) M__floor__() (Object, error)

func (a *BigInt) M__floordiv__(other Object) (Object, error)

func (a *BigInt) M__ge__(other Object) (Object, error)

func (a *BigInt) M__gt__(other Object) (Object, error)

func (a *BigInt) M__iadd__(other Object) (Object, error)

func (a *BigInt) M__iand__(other Object) (Object, error)

func (a *BigInt) M__ifloordiv__(other Object) (Object, error)

func (a *BigInt) M__ilshift__(other Object) (Object, error)

func (a *BigInt) M__imod__(other Object) (Object, error)

func (a *BigInt) M__imul__(other Object) (Object, error)

func (a *BigInt) M__index__() (Int, error)

func (a *BigInt) M__int__() (Object, error)

func (a *BigInt) M__invert__() (Object, error)

func (a *BigInt) M__ior__(other Object) (Object, error)

func (a *BigInt) M__ipow__(other, modulus Object) (Object, error)

func (a *BigInt) M__irshift__(other Object) (Object, error)

func (a *BigInt) M__isub__(other Object) (Object, error)

func (a *BigInt) M__itruediv__(other Object) (Object, error)

func (a *BigInt) M__ixor__(other Object) (Object, error)

func (a *BigInt) M__le__(other Object) (Object, error)

func (a *BigInt) M__lshift__(other Object) (Object, error)

func (a *BigInt) M__lt__(other Object) (Object, error)

func (a *BigInt) M__mod__(other Object) (Object, error)

func (a *BigInt) M__mul__(other Object) (Object, error)

func (a *BigInt) M__ne__(other Object) (Object, error)

func (a *BigInt) M__neg__() (Object, error)

func (a *BigInt) M__or__(other Object) (Object, error)

func (a *BigInt) M__pos__() (Object, error)

func (a *BigInt) M__pow__(other, modulus Object) (Object, error)

func (a *BigInt) M__radd__(other Object) (Object, error)

func (a *BigInt) M__rand__(other Object) (Object, error)

func (a *BigInt) M__rdivmod__(other Object) (Object, Object, error)

func (a *BigInt) M__repr__() (Object, error)

func (a *BigInt) M__rfloordiv__(other Object) (Object, error)

func (a *BigInt) M__rlshift__(other Object) (Object, error)

func (a *BigInt) M__rmod__(other Object) (Object, error)

func (a *BigInt) M__rmul__(other Object) (Object, error)

func (a *BigInt) M__ror__(other Object) (Object, error)

func (a *BigInt) M__round__(digits Object) (Object, error)

func (a *BigInt) M__rpow__(other Object) (Object, error)

func (a *BigInt) M__rrshift__(other Object) (Object, error)

func (a *BigInt) M__rshift__(other Object) (Object, error)

func (a *BigInt) M__rsub__(other Object) (Object, error)

func (a *BigInt) M__rtruediv__(other Object) (Object, error)

func (a *BigInt) M__rxor__(other Object) (Object, error)

func (a *BigInt) M__str__() (Object, error)

func (a *BigInt) M__sub__(other Object) (Object, error)

func (a *BigInt) M__truediv__(other Object) (Object, error)

func (a *BigInt) M__trunc__() (Object, error)

func (a *BigInt) M__xor__(other Object) (Object, error)

func (x *BigInt) MaybeInt() Object

func (o *BigInt) Type() *Type

type Bool ¶

type Bool bool

func NewBool(t bool) Bool

func (a Bool) M__bool__() (Object, error)

func (a Bool) M__eq__(other Object) (Object, error)

func (a Bool) M__index__() (Int, error)

func (a Bool) M__ne__(other Object) (Object, error)

func (a Bool) M__repr__() (Object, error)

func (a Bool) M__str__() (Object, error)

func (s Bool) Type() *Type

type BoundMethod ¶

type BoundMethod struct {
	Self   Object
	Method Object
}

A python BoundMethod object

func NewBoundMethod(self, method Object) *BoundMethod

func (bm *BoundMethod) M__call__(args Tuple, kwargs StringDict) (Object, error)

func (o *BoundMethod) Type() *Type

type Bytes ¶

type Bytes []byte

func BytesFromObject(x Object) (Bytes, error)

func (a Bytes) M__add__(other Object) (Object, error)

func (a Bytes) M__eq__(other Object) (Object, error)

func (a Bytes) M__ge__(other Object) (Object, error)

func (a Bytes) M__gt__(other Object) (Object, error)

func (a Bytes) M__iadd__(other Object) (Object, error)

func (a Bytes) M__le__(other Object) (Object, error)

func (a Bytes) M__lt__(other Object) (Object, error)

func (a Bytes) M__ne__(other Object) (Object, error)

func (a Bytes) M__repr__() (Object, error)

func (a Bytes) M__str__() (Object, error)

func (a Bytes) Replace(args Tuple) (Object, error)

func (o Bytes) Type() *Type

type CallIterator ¶ added in v0.1.0

type CallIterator struct {
	// contains filtered or unexported fields
}

A python CallIterator object

func NewCallIterator(callable Object, sentinel Object) *CallIterator

func (cit *CallIterator) M__iter__() (Object, error)

func (cit *CallIterator) M__next__() (Object, error)

func (o *CallIterator) Type() *Type

type Cell ¶

type Cell struct {
	// contains filtered or unexported fields
}

A python Cell object

func NewCell(obj Object) *Cell

func (c *Cell) Delete()

func (c *Cell) Get() Object

func (c *Cell) Set(obj Object)

func (o *Cell) Type() *Type

type ClassMethod ¶

type ClassMethod struct {
	Callable Object
	Dict     StringDict
}

func (c *ClassMethod) GetDict() StringDict

func (c *ClassMethod) M__get__(instance, owner Object) (Object, error)

func (o ClassMethod) Type() *Type

type Code ¶

type Code struct {
	Argcount       int32    // #arguments, except *args
	Kwonlyargcount int32    // #keyword only arguments
	Nlocals        int32    // #local variables
	Stacksize      int32    // #entries needed for evaluation stack
	Flags          int32    // CO_..., see below
	Code           string   // instruction opcodes
	Consts         Tuple    // list (constants used)
	Names          []string // list of strings (names used)
	Varnames       []string // tuple of strings (local variable names)
	Freevars       []string // tuple of strings (free variable names)
	Cellvars       []string // tuple of strings (cell variable names)
	// The rest doesn't count for hash or comparisons
	Cell2arg    []byte // Maps cell vars which are arguments.
	Filename    string // unicode (where it was loaded from)
	Name        string // unicode (name, for reference)
	Firstlineno int32  // first source line number
	Lnotab      string // string (encoding addr<->lineno mapping) See Objects/lnotab_notes.txt for details.

	Weakreflist *List // to support weakrefs to code objects
}

Code object

Freevars are variables declared in the namespace where the code object was defined, they are used when closures are used - these become Cellvars in the function with a closure.

Cellvars are names of local variables referenced by functions with a closure.

func NewCode(argcount int32, kwonlyargcount int32,
	nlocals int32, stacksize int32, flags int32,
	code_ Object, consts_ Object, names_ Object,
	varnames_ Object, freevars_ Object, cellvars_ Object,
	filename_ Object, name_ Object, firstlineno int32,
	lnotab_ Object) *Code

func (co *Code) Addr2Line(addrq int32) int32

func (co *Code) GetNumFree() int

func (co *Code) M__eq__(other Object) (Object, error)

func (co *Code) M__ne__(other Object) (Object, error)

func (o *Code) Type() *Type

type CompileMode ¶ added in v0.1.0

type CompileMode string

const (
	ExecMode   CompileMode = "exec"   // Compile a module
	EvalMode   CompileMode = "eval"   // Compile an expression
	SingleMode CompileMode = "single" // Compile a single (interactive) statement
)

type CompileOpts ¶ added in v0.1.0

type CompileOpts struct {
	UseSysPaths bool   // If set, sys.path will be used to resolve relative pathnames
	CurDir      string // If non-empty, this is the path of the current working directory.  If empty, os.Getwd() is used.
}

CompileOpts specifies options for high-level compilation.

type CompileOut ¶ added in v0.1.0

type CompileOut struct {
	SrcPathname string // Resolved pathname the .py file that was compiled (if applicable)
	PycPathname string // Pathname of the .pyc file read and/or written (if applicable)
	FileDesc    string // Pathname to be used for a a module's "__file__" attrib
	Code        *Code  // Read/Output code object ready for execution
}

CompileOut the output of high-level compilation -- e.g. ResolveAndCompile()

type Complex ¶

type Complex complex128

func (a Complex) M__abs__() (Object, error)

func (a Complex) M__add__(other Object) (Object, error)

func (a Complex) M__complex__() (Object, error)

func (a Complex) M__divmod__(other Object) (Object, Object, error)

func (a Complex) M__eq__(other Object) (Object, error)

func (a Complex) M__float__() (Object, error)

func (a Complex) M__floordiv__(other Object) (Object, error)

func (a Complex) M__ge__(other Object) (Object, error)

func (a Complex) M__gt__(other Object) (Object, error)

func (a Complex) M__iadd__(other Object) (Object, error)

func (a Complex) M__ifloordiv__(other Object) (Object, error)

func (a Complex) M__imod__(other Object) (Object, error)

func (a Complex) M__imul__(other Object) (Object, error)

func (a Complex) M__int__() (Object, error)

func (a Complex) M__ipow__(other, modulus Object) (Object, error)

func (a Complex) M__isub__(other Object) (Object, error)

func (a Complex) M__itruediv__(other Object) (Object, error)

func (a Complex) M__le__(other Object) (Object, error)

func (a Complex) M__lt__(other Object) (Object, error)

func (a Complex) M__mod__(other Object) (Object, error)

func (a Complex) M__mul__(other Object) (Object, error)

func (a Complex) M__ne__(other Object) (Object, error)

func (a Complex) M__neg__() (Object, error)

func (a Complex) M__pos__() (Object, error)

func (a Complex) M__pow__(other, modulus Object) (Object, error)

func (a Complex) M__radd__(other Object) (Object, error)

func (a Complex) M__rdivmod__(other Object) (Object, Object, error)

func (a Complex) M__repr__() (Object, error)

func (a Complex) M__rfloordiv__(other Object) (Object, error)

func (a Complex) M__rmod__(other Object) (Object, error)

func (a Complex) M__rmul__(other Object) (Object, error)

func (a Complex) M__rpow__(other Object) (Object, error)

func (a Complex) M__rsub__(other Object) (Object, error)

func (a Complex) M__rtruediv__(other Object) (Object, error)

func (a Complex) M__str__() (Object, error)

func (a Complex) M__sub__(other Object) (Object, error)

func (a Complex) M__truediv__(other Object) (Object, error)

func (o Complex) Type() *Type

type Context ¶ added in v0.1.0

type Context interface {

	// Resolves then compiles (if applicable) the given file system pathname into a py.Code ready to be executed.
	ResolveAndCompile(pathname string, opts CompileOpts) (CompileOut, error)

	// Creates a new py.Module instance and initializes ModuleImpl's code in the new module (if applicable).
	ModuleInit(impl *ModuleImpl) (*Module, error)

	// RunCode is a lower-level invocation to execute the given py.Code.
	// Blocks until execution is complete.
	RunCode(code *Code, globals, locals StringDict, closure Tuple) (result Object, err error)

	// Returns the named module for this context (or an error if not found)
	GetModule(moduleName string) (*Module, error)

	// Gereric access to this context's modules / state.
	Store() *ModuleStore

	// Close signals this context is about to go out of scope and any internal resources should be released.
	// Code execution on a py.Context that has been closed will result in an error.
	Close() error

	// Done returns a signal that can be used to detect when this Context has fully closed / completed.
	// If Close() is called while execution in progress, Done() will not signal until execution is complete.
	Done() <-chan struct{}
}

Context is a gpython environment instance container, providing a high-level mechanism for multiple python interpreters to run concurrently without restriction.

Context instances maintain completely independent environments, namely the modules that have been imported and their state. Modules imported into a Context are instanced from a parent ModuleImpl. For example, since Contexts each have their own sys module instance, each can set sys.path differently and independently.

If you access a Context from multiple groutines, you are responsible that access is not concurrent, with the exception of Close() and Done().

See examples/multi-context and examples/embedding.

type ContextOpts ¶ added in v0.1.0

type ContextOpts struct {
	SysArgs  []string // sys.argv initializer
	SysPaths []string // sys.path initializer
}

ContextOpts specifies fundamental environment and input settings for creating a new py.Context

type EllipsisType ¶

type EllipsisType struct{}

func (a EllipsisType) M__bool__() (Object, error)

func (a EllipsisType) M__eq__(other Object) (Object, error)

func (a EllipsisType) M__ne__(other Object) (Object, error)

func (a EllipsisType) M__repr__() (Object, error)

func (s EllipsisType) Type() *Type

type Enumerate ¶ added in v0.1.0

type Enumerate struct {
	Iterable Object
	Start    Int
}

A python Enumerate object

func (e *Enumerate) M__iter__() (Object, error)

func (e *Enumerate) Type() *Type

type EnumerateIterator ¶ added in v0.1.0

type EnumerateIterator struct {
	Enumerate
	Index Int
}

A python Enumerate iterator

func (ei *EnumerateIterator) M__iter__() (Object, error)

func (ei *EnumerateIterator) M__next__() (Object, error)

func (ei *EnumerateIterator) Type() *Type

type Exception ¶

type Exception struct {
	Base            *Type
	Args            Object
	Traceback       Object
	Context         Object
	Cause           Object
	SuppressContext bool
	Dict            StringDict // anything else that we want to stuff in
}

A python Exception object

func ExceptionNewf(metatype *Type, format string, a ...interface{}) *Exception

func MakeException(r interface{}) *Exception

func MakeSyntaxError(r interface{}, filename string, lineno int, offset int, line string) *Exception

func (e *Exception) Error() string

func (e *Exception) M__getattr__(name string) (Object, error)

func (e *Exception) M__repr__() (Object, error)

func (e *Exception) M__str__() (Object, error)

func (e *Exception) Type() *Type

type ExceptionInfo ¶

type ExceptionInfo struct {
	Type      *Type
	Value     Object
	Traceback *Traceback
}

A python exception info block

func (e ExceptionInfo) Error() string

func (exc *ExceptionInfo) IsSet() bool

func (exc *ExceptionInfo) TracebackDump(w io.Writer)

type File ¶

type File struct {
	*os.File
	FileMode
}

func (o *File) Can(mode FileMode) bool

func (o *File) Close() (Object, error)

func (o *File) Flush() (Object, error)

func (o *File) M__enter__() (Object, error)

func (o *File) M__exit__(exc_type, exc_value, traceback Object) (Object, error)

func (o *File) Read(args Tuple, kwargs StringDict) (Object, error)

func (o *File) Type() *Type

func (o *File) Write(value Object) (Object, error)

type FileMode ¶ added in v0.0.3

type FileMode int

const (
	FileRead   FileMode = 0x01
	FileWrite  FileMode = 0x02
	FileText   FileMode = 0x4000
	FileBinary FileMode = 0x8000

	FileReadWrite = FileRead + FileWrite
)

func FileModeFrom(mode string) (perm FileMode, trunc, excl bool, err error)

type Filter ¶ added in v0.2.0

type Filter struct {
	// contains filtered or unexported fields
}

A python Filter object

func (f *Filter) M__iter__() (Object, error)

func (f *Filter) M__next__() (Object, error)

func (f *Filter) Type() *Type

type Float ¶

type Float float64

func FloatCheck(obj Object) (Float, error)

func FloatCheckExact(obj Object) (Float, error)

func (a Float) M__abs__() (Object, error)

func (a Float) M__add__(other Object) (Object, error)

func (a Float) M__bool__() (Object, error)

func (a Float) M__complex__() (Object, error)

func (a Float) M__divmod__(other Object) (Object, Object, error)

func (a Float) M__eq__(other Object) (Object, error)

func (a Float) M__float__() (Object, error)

func (a Float) M__floordiv__(other Object) (Object, error)

func (a Float) M__ge__(other Object) (Object, error)

func (a Float) M__gt__(other Object) (Object, error)

func (a Float) M__iadd__(other Object) (Object, error)

func (a Float) M__ifloordiv__(other Object) (Object, error)

func (a Float) M__imod__(other Object) (Object, error)

func (a Float) M__imul__(other Object) (Object, error)

func (a Float) M__int__() (Object, error)

func (a Float) M__ipow__(other, modulus Object) (Object, error)

func (a Float) M__isub__(other Object) (Object, error)

func (a Float) M__itruediv__(other Object) (Object, error)

func (a Float) M__le__(other Object) (Object, error)

func (a Float) M__lt__(other Object) (Object, error)

func (a Float) M__mod__(other Object) (Object, error)

func (a Float) M__mul__(other Object) (Object, error)

func (a Float) M__ne__(other Object) (Object, error)

func (a Float) M__neg__() (Object, error)

func (a Float) M__pos__() (Object, error)

func (a Float) M__pow__(other, modulus Object) (Object, error)

func (a Float) M__radd__(other Object) (Object, error)

func (a Float) M__rdivmod__(other Object) (Object, Object, error)

func (a Float) M__repr__() (Object, error)

func (a Float) M__rfloordiv__(other Object) (Object, error)

func (a Float) M__rmod__(other Object) (Object, error)

func (a Float) M__rmul__(other Object) (Object, error)

func (a Float) M__round__(digitsObj Object) (Object, error)

func (a Float) M__rpow__(other Object) (Object, error)

func (a Float) M__rsub__(other Object) (Object, error)

func (a Float) M__rtruediv__(other Object) (Object, error)

func (a Float) M__str__() (Object, error)

func (a Float) M__sub__(other Object) (Object, error)

func (a Float) M__truediv__(other Object) (Object, error)

func (o Float) Type() *Type

type Frame ¶

type Frame struct {
	// Back       *Frame        // previous frame, or nil
	Context         Context    // host module (state) context
	Code            *Code      // code segment
	Builtins        StringDict // builtin symbol table
	Globals         StringDict // global symbol table
	Locals          StringDict // local symbol table
	Stack           []Object   // Valuestack
	LocalVars       Tuple      // Fast access local vars
	CellAndFreeVars Tuple      // Cellvars then Freevars Cell objects in one Tuple

	// Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
	// Frame evaluation usually NULLs it, but a frame that yields sets it
	// to the current stack top.
	// Stacktop *Object
	Yielded bool // set if the function yielded, cleared otherwise

	// FIXME Tstate *PyThreadState
	Lasti int32 // Last instruction if called
	// Call PyFrame_GetLineNumber() instead of reading this field
	// directly.  As of 2.3 f_lineno is only valid when tracing is
	// active (i.e. when f_trace is set).  At other times we use
	// PyCode_Addr2Line to calculate the line from the current
	// bytecode index.
	// Lineno     int        // Current line number
	// Iblock     int        // index in f_blockstack
	// Executing  byte       // whether the frame is still executing
	Blockstack []TryBlock // for try and loop blocks
	Block      *TryBlock  // pointer to current block or nil
	Localsplus []Object   // LocalVars + CellAndFreeVars
}

A python Frame object

func NewFrame(ctx Context, globals, locals StringDict, code *Code, closure Tuple) *Frame

func (f *Frame) FastToLocals()

func (f *Frame) LocalsToFast(clear bool)

func (f *Frame) Lookup(name string) (obj Object, ok bool)

func (f *Frame) LookupGlobal(name string) (obj Object, ok bool)

func (f *Frame) PopBlock()

func (f *Frame) PushBlock(Type TryBlockType, Handler int32, Level int)

func (o *Frame) Type() *Type

type FrozenSet ¶

type FrozenSet struct {
	Set
}

func NewFrozenSet() *FrozenSet

func NewFrozenSetFromItems(items []Object) *FrozenSet

func (o *FrozenSet) Type() *Type

type Function ¶

type Function struct {
	Code        *Code      // A code object, the __code__ attribute
	Context     Context    // Host VM context
	Globals     StringDict // A dictionary (other mappings won't do)
	Defaults    Tuple      // NULL or a tuple
	KwDefaults  StringDict // NULL or a dict
	Closure     Tuple      // NULL or a tuple of cell objects
	Doc         Object     // The __doc__ attribute, can be anything
	Name        string     // The __name__ attribute, a string object
	Dict        StringDict // The __dict__ attribute, a dict or NULL
	Weakreflist List       // List of weak references
	Annotations StringDict // Annotations, a dict or NULL
	Qualname    string     // The qualified name
}

A python Function object

func NewFunction(ctx Context, code *Code, globals StringDict, qualname string) *Function

func (f *Function) GetDict() StringDict

func (f *Function) M__call__(args Tuple, kwargs StringDict) (Object, error)

func (f *Function) M__get__(instance, owner Object) (Object, error)

func (o *Function) Type() *Type

type Generator ¶

type Generator struct {
	// Note: gi_frame can be NULL if the generator is "finished"
	Frame *Frame

	// True if generator is being executed.
	Running bool

	// The code object backing the generator
	Code *Code

	// List of weak reference.
	Weakreflist Object
}

A python Generator object

func NewGenerator(frame *Frame) *Generator

func (it *Generator) Close() (Object, error)

func (it *Generator) M__iter__() (Object, error)

func (it *Generator) M__next__() (Object, error)

func (it *Generator) Send(arg Object) (Object, error)

func (it *Generator) Throw(args Tuple, kwargs StringDict) (Object, error)

func (o *Generator) Type() *Type

type IGetDict ¶

type IGetDict interface {
	GetDict() StringDict
}

Optional interfaces

type IGoInt ¶

type IGoInt interface {
	GoInt() (int, error)
}

type IGoInt64 ¶

type IGoInt64 interface {
	GoInt64() (int64, error)
}

type I__abs__ ¶

type I__abs__ interface {
	M__abs__() (Object, error)
}

object.__abs__(self)

type I__add__ ¶

type I__add__ interface {
	M__add__(other Object) (Object, error)
}

object.__add__(self, other)

type I__and__ ¶

type I__and__ interface {
	M__and__(other Object) (Object, error)
}

object.__and__(self, other)

type I__bool__ ¶

type I__bool__ interface {
	M__bool__() (Object, error)
}

Called to implement truth value testing and the built-in operation bool(); should return False or True. When this method is not defined, __len__() is called, if it is defined, and the object is considered true if its result is nonzero. If a class defines neither __len__() nor __bool__(), all its instances are considered true. object.__bool__(self)

type I__bytes__ ¶

type I__bytes__ interface {
	M__bytes__() (Object, error)
}

Called by bytes() to compute a byte-string representation of an object. This should return a bytes object. object.__bytes__(self)

type I__call__ ¶

type I__call__ interface {
	M__call__(args Tuple, kwargs StringDict) (Object, error)
}

Called when the instance is “called” as a function; if this method is defined, x(arg1, arg2, ...) is a shorthand for x.__call__(arg1, arg2, ...). object.__call__(self[, args...])

type I__ceil__ ¶

type I__ceil__ interface {
	M__ceil__() (Object, error)
}

Return the ceiling of x, the smallest integer greater than or equal to x. If x is not a float, delegates to x.__ceil__(), which should return an Integral value. object.__float__(self)

type I__complex__ ¶

type I__complex__ interface {
	M__complex__() (Object, error)
}

object.__complex__(self)

type I__contains__ ¶

type I__contains__ interface {
	M__contains__(item Object) (Object, error)
}

Called to implement membership test operators. Should return true if item is in self, false otherwise. For mapping objects, this should consider the keys of the mapping rather than the values or the key-item pairs.

For objects that don’t define __contains__(), the membership test first tries iteration via __iter__(), then the old sequence iteration protocol via __getitem__(), see this section in the language reference. object.__contains__(self, item)

type I__del__ ¶

type I__del__ interface {
	M__del__() (Object, error)
}

Called when the instance is about to be destroyed. This is also called a destructor. If a base class has a __del__() method, the derived class’s __del__() method, if any, must explicitly call it to ensure proper deletion of the base class part of the instance. Note that it is possible (though not recommended!) for the __del__() method to postpone destruction of the instance by creating a new reference to it. It may then be called at a later time when this new reference is deleted. It is not guaranteed that __del__() methods are called for objects that still exist when the interpreter exits.

Note del x doesn’t directly call x.__del__() — the former decrements the reference count for x by one, and the latter is only called when x‘s reference count reaches zero. Some common situations that may prevent the reference count of an object from going to zero include: circular references between objects (e.g., a doubly-linked list or a tree data structure with parent and child pointers); a reference to the object on the stack frame of a function that caught an exception (the traceback stored in sys.exc_info()[2] keeps the stack frame alive); or a reference to the object on the stack frame that raised an unhandled exception in interactive mode (the traceback stored in sys.last_traceback keeps the stack frame alive). The first situation can only be remedied by explicitly breaking the cycles; the latter two situations can be resolved by storing None in sys.last_traceback. Circular references which are garbage are detected and cleaned up when the cyclic garbage collector is enabled (it’s on by default). Refer to the documentation for the gc module for more information about this topic.

Warning Due to the precarious circumstances under which __del__() methods are invoked, exceptions that occur during their execution are ignored, and a warning is printed to sys.stderr instead. Also, when __del__() is invoked in response to a module being deleted (e.g., when execution of the program is done), other globals referenced by the __del__() method may already have been deleted or in the process of being torn down (e.g. the import machinery shutting down). For this reason, __del__() methods should do the absolute minimum needed to maintain external invariants. Starting with version 1.5, Python guarantees that globals whose name begins with a single underscore are deleted from their module before other globals are deleted; if no other references to such globals exist, this may help in assuring that imported modules are still available at the time when the __del__() method is called. object.__del__(self)

type I__delattr__ ¶

type I__delattr__ interface {
	M__delattr__(name string) (Object, error)
}

Like __setattr__() but for attribute deletion instead of assignment. This should only be implemented if del obj.name is meaningful for the object. object.__delattr__(self, name)

type I__delete__ ¶

type I__delete__ interface {
	M__delete__(instance Object) (Object, error)
}

Called to delete the attribute on an instance instance of the owner class. object.__delete__(self, instance)

type I__delitem__ ¶

type I__delitem__ interface {
	M__delitem__(key Object) (Object, error)
}

Called to implement deletion of self[key]. Same note as for __getitem__(). This should only be implemented for mappings if the objects support removal of keys, or for sequences if elements can be removed from the sequence. The same exceptions should be raised for improper key values as for the __getitem__() method. object.__delitem__(self, key)

type I__dir__ ¶

type I__dir__ interface {
	M__dir__() (Object, error)
}

Called when dir() is called on the object. A sequence must be returned. dir() converts the returned sequence to a list and sorts it. object.__dir__(self)

type I__divmod__ ¶

type I__divmod__ interface {
	M__divmod__(other Object) (Object, Object, error)
}

object.__divmod__(self, other)

type I__enter__ ¶

type I__enter__ interface {
	M__enter__() (Object, error)
}

Enter the runtime context related to this object. The with statement will bind this method’s return value to the target(s) specified in the as clause of the statement, if any. object.__enter__(self)

type I__eq__ ¶

type I__eq__ interface {
	M__eq__(other Object) (Object, error)
}

object.__eq__(self, other)

type I__exit__ ¶

type I__exit__ interface {
	M__exit__(exc_type, exc_value, traceback Object) (Object, error)
}

Exit the runtime context related to this object. The parameters describe the exception that caused the context to be exited. If the context was exited without an exception, all three arguments will be None.

If an exception is supplied, and the method wishes to suppress the exception (i.e., prevent it from being propagated), it should return a true value. Otherwise, the exception will be processed normally upon exit from this method.

Note that __exit__() methods should not reraise the passed-in exception; this is the caller’s responsibility. object.__exit__(self, exc_type, exc_value, traceback)

type I__float__ ¶

type I__float__ interface {
	M__float__() (Object, error)
}

object.__float__(self)

type I__floor__ ¶

type I__floor__ interface {
	M__floor__() (Object, error)
}

Return the floor of x, the largest integer less than or equal to x. If x is not a float, delegates to x.__floor__(), which should return an Integral value.

type I__floordiv__ ¶

type I__floordiv__ interface {
	M__floordiv__(other Object) (Object, error)
}

object.__floordiv__(self, other)

type I__format__ ¶

type I__format__ interface {
	M__format__(format_spec Object) (Object, error)
}

Called by the format() built-in function (and by extension, the str.format() method of class str) to produce a “formatted” string representation of an object. The format_spec argument is a string that contains a description of the formatting options desired. The interpretation of the format_spec argument is up to the type implementing __format__(), however most classes will either delegate formatting to one of the built-in types, or use a similar formatting option syntax.

See Format Specification Mini-Language for a description of the standard formatting syntax.

The return value must be a string object. object.__format__(self, format_spec)

type I__ge__ ¶

type I__ge__ interface {
	M__ge__(other Object) (Object, error)
}

object.__ge__(self, other)

type I__get__ ¶

type I__get__ interface {
	M__get__(instance, owner Object) (Object, error)
}

Called to get the attribute of the owner class (class attribute access) or of an instance of that class (instance attribute access). owner is always the owner class, while instance is the instance that the attribute was accessed through, or None when the attribute is accessed through the owner. This method should return the (computed) attribute value or raise an AttributeError exception. object.__get__(self, instance, owner)

type I__getattr__ ¶

type I__getattr__ interface {
	M__getattr__(name string) (Object, error)
}

Called when an attribute lookup has not found the attribute in the usual places (i.e. it is not an instance attribute nor is it found in the class tree for self). name is the attribute name. This method should return the (computed) attribute value or raise an AttributeError exception.

Note that if the attribute is found through the normal mechanism, __getattr__() is not called. (This is an intentional asymmetry between __getattr__() and __setattr__().) This is done both for efficiency reasons and because otherwise __getattr__() would have no way to access other attributes of the instance. Note that at least for instance variables, you can fake total control by not inserting any values in the instance attribute dictionary (but instead inserting them in another object). See the __getattribute__() method below for a way to actually get total control over attribute access. object.__getattr__(self, name)

type I__getattribute__ ¶

type I__getattribute__ interface {
	M__getattribute__(name string) (Object, error)
}

Called unconditionally to implement attribute accesses for instances of the class. If the class also defines __getattr__(), the latter will not be called unless __getattribute__() either calls it explicitly or raises an AttributeError. This method should return the (computed) attribute value or raise an AttributeError exception. In order to avoid infinite recursion in this method, its implementation should always call the base class method with the same name to access any attributes it needs, for example, object.__getattribute__(self, name).

Note This method may still be bypassed when looking up special methods as the result of implicit invocation via language syntax or built-in functions. See Special method lookup. object.__getattribute__(self, name)

type I__getitem__ ¶

type I__getitem__ interface {
	M__getitem__(key Object) (Object, error)
}

Called to implement evaluation of self[key]. For sequence types, the accepted keys should be integers and slice objects. Note that the special interpretation of negative indexes (if the class wishes to emulate a sequence type) is up to the __getitem__() method. If key is of an inappropriate type, TypeError may be raised; if of a value outside the set of indexes for the sequence (after any special interpretation of negative values), IndexError should be raised. For mapping types, if key is missing (not in the container), KeyError should be raised.

Note for loops expect that an IndexError will be raised for illegal indexes to allow proper detection of the end of the sequence. object.__getitem__(self, key)

type I__gt__ ¶

type I__gt__ interface {
	M__gt__(other Object) (Object, error)
}

object.__gt__(self, other)

type I__hash__ ¶

type I__hash__ interface {
	M__hash__() (Object, error)
}

Called by built-in function hash() and for operations on members of hashed collections including set, frozenset, and dict. __hash__() should return an integer. The only required property is that objects which compare equal have the same hash value; it is advised to somehow mix together (e.g. using exclusive or) the hash values for the components of the object that also play a part in comparison of objects.

Note hash() truncates the value returned from an object’s custom __hash__() method to the size of a Py_ssize_t. This is typically 8 bytes on 64-bit builds and 4 bytes on 32-bit builds. If an object’s __hash__() must interoperate on builds of different bit sizes, be sure to check the width on all supported builds. An easy way to do this is with python -c "import sys; print(sys.hash_info.width)"

If a class does not define an __eq__() method it should not define a __hash__() operation either; if it defines __eq__() but not __hash__(), its instances will not be usable as items in hashable collections. If a class defines mutable objects and implements an __eq__() method, it should not implement __hash__(), since the implementation of hashable collections requires that a key’s hash value is immutable (if the object’s hash value changes, it will be in the wrong hash bucket).

User-defined classes have __eq__() and __hash__() methods by default; with them, all objects compare unequal (except with themselves) and x.__hash__() returns an appropriate value such that x == y implies both that x is y and hash(x) == hash(y).

A class that overrides __eq__() and does not define __hash__() will have its __hash__() implicitly set to None. When the __hash__() method of a class is None, instances of the class will raise an appropriate TypeError when a program attempts to retrieve their hash value, and will also be correctly identified as unhashable when checking isinstance(obj, collections.Hashable).

If a class that overrides __eq__() needs to retain the implementation of __hash__() from a parent class, the interpreter must be told this explicitly by setting __hash__ = <ParentClass>.__hash__.

If a class that does not override __eq__() wishes to suppress hash support, it should include __hash__ = None in the class definition. A class which defines its own __hash__() that explicitly raises a TypeError would be incorrectly identified as hashable by an isinstance(obj, collections.Hashable) call.

Note By default, the __hash__() values of str, bytes and datetime objects are “salted” with an unpredictable random value. Although they remain constant within an individual Python process, they are not predictable between repeated invocations of Python.

This is intended to provide protection against a denial-of-service caused by carefully-chosen inputs that exploit the worst case performance of a dict insertion, O(n^2) complexity. See http://www.ocert.org/advisories/ocert-2011-003.html for details.

Changing hash values affects the iteration order of dicts, sets and other mappings. Python has never made guarantees about this ordering (and it typically varies between 32-bit and 64-bit builds).

See also PYTHONHASHSEED.

Changed in version 3.3: Hash randomization is enabled by default. object.__hash__(self)

type I__iadd__ ¶

type I__iadd__ interface {
	M__iadd__(other Object) (Object, error)
}

object.__iadd__(self, other)

type I__iand__ ¶

type I__iand__ interface {
	M__iand__(other Object) (Object, error)
}

object.__iand__(self, other)

type I__ifloordiv__ ¶

type I__ifloordiv__ interface {
	M__ifloordiv__(other Object) (Object, error)
}

object.__ifloordiv__(self, other)

type I__ilshift__ ¶

type I__ilshift__ interface {
	M__ilshift__(other Object) (Object, error)
}

object.__ilshift__(self, other)

type I__imod__ ¶

type I__imod__ interface {
	M__imod__(other Object) (Object, error)
}

object.__imod__(self, other)

type I__imul__ ¶

type I__imul__ interface {
	M__imul__(other Object) (Object, error)
}

object.__imul__(self, other)

type I__index__ ¶

type I__index__ interface {
	M__index__() (Int, error)
}

object.__index__(self)

type I__init__ ¶

type I__init__ interface {
	M__init__(self, args, kwargs Object) (Object, error)
}

Called when the instance is created. The arguments are those passed to the class constructor expression. If a base class has an __init__() method, the derived class’s __init__() method, if any, must explicitly call it to ensure proper initialization of the base class part of the instance; for example: BaseClass.__init__(self, [args...]). As a special constraint on constructors, no value may be returned; doing so will cause a TypeError to be raised at runtime. object.__init__(self[, ...])

type I__instancecheck__ ¶

type I__instancecheck__ interface {
	M__instancecheck__(instance Object) (Object, error)
}

Return true if instance should be considered a (direct or indirect) instance of class. If defined, called to implement isinstance(instance, class). object.__instancecheck__(self, instance)

type I__int__ ¶

type I__int__ interface {
	M__int__() (Object, error)
}

object.__int__(self)

type I__invert__ ¶

type I__invert__ interface {
	M__invert__() (Object, error)
}

object.__invert__(self)

type I__ior__ ¶

type I__ior__ interface {
	M__ior__(other Object) (Object, error)
}

object.__ior__(self, other)

type I__ipow__ ¶

type I__ipow__ interface {
	M__ipow__(other, modulo Object) (Object, error)
}

type I__irshift__ ¶

type I__irshift__ interface {
	M__irshift__(other Object) (Object, error)
}

object.__irshift__(self, other)

type I__isub__ ¶

type I__isub__ interface {
	M__isub__(other Object) (Object, error)
}

object.__isub__(self, other)

type I__iter__ ¶

type I__iter__ interface {
	M__iter__() (Object, error)
}

This method is called when an iterator is required for a container. This method should return a new iterator object that can iterate over all the objects in the container. For mappings, it should iterate over the keys of the container, and should also be made available as the method keys().

Iterator objects also need to implement this method; they are required to return themselves. For more information on iterator objects, see Iterator Types. object.__iter__(self)

type I__itruediv__ ¶

type I__itruediv__ interface {
	M__itruediv__(other Object) (Object, error)
}

object.__itruediv__(self, other)

type I__ixor__ ¶

type I__ixor__ interface {
	M__ixor__(other Object) (Object, error)
}

object.__ixor__(self, other)

type I__le__ ¶

type I__le__ interface {
	M__le__(other Object) (Object, error)
}

object.__le__(self, other)

type I__len__ ¶

type I__len__ interface {
	M__len__() (Object, error)
}

Called to implement the built-in function len(). Should return the length of the object, an integer >= 0. Also, an object that doesn’t define a __bool__() method and whose __len__() method returns zero is considered to be false in a Boolean context. object.__len__(self)

type I__length_hint__ ¶

type I__length_hint__ interface {
	M__length_hint__() (Object, error)
}

Called to implement operator.length_hint(). Should return an estimated length for the object (which may be greater or less than the actual length). The length must be an integer >= 0. This method is purely an optimization and is never required for correctness.

New in version 3.4. object.__length_hint__(self)

type I__lshift__ ¶

type I__lshift__ interface {
	M__lshift__(other Object) (Object, error)
}

object.__lshift__(self, other)

type I__lt__ ¶

type I__lt__ interface {
	M__lt__(other Object) (Object, error)
}

These are the so-called “rich comparison” methods. The correspondence between operator symbols and method names is as follows: x<y calls x.__lt__(y), x<=y calls x.__le__(y), x==y calls x.__eq__(y), x!=y calls x.__ne__(y), x>y calls x.__gt__(y), and x>=y calls x.__ge__(y).

A rich comparison method may return the singleton NotImplemented if it does not implement the operation for a given pair of arguments. By convention, False and True are returned for a successful comparison. However, these methods can return any value, so if the comparison operator is used in a Boolean context (e.g., in the condition of an if statement), Python will call bool() on the value to determine if the result is true or false.

There are no implied relationships among the comparison operators. The truth of x==y does not imply that x!=y is false. Accordingly, when defining __eq__(), one should also define __ne__() so that the operators will behave as expected. See the paragraph on __hash__() for some important notes on creating hashable objects which support custom comparison operations and are usable as dictionary keys.

There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, __lt__() and __gt__() are each other’s reflection, __le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection.

Arguments to rich comparison methods are never coerced.

To automatically generate ordering operations from a single root operation, see functools.total_ordering(). object.__lt__(self, other)

type I__mod__ ¶

type I__mod__ interface {
	M__mod__(other Object) (Object, error)
}

object.__mod__(self, other)

type I__mul__ ¶

type I__mul__ interface {
	M__mul__(other Object) (Object, error)
}

object.__mul__(self, other)

type I__ne__ ¶

type I__ne__ interface {
	M__ne__(other Object) (Object, error)
}

object.__ne__(self, other)

type I__neg__ ¶

type I__neg__ interface {
	M__neg__() (Object, error)
}

object.__neg__(self)

type I__new__ ¶

type I__new__ interface {
	M__new__(cls, args, kwargs Object) (Object, error)
}

Called to create a new instance of class cls. __new__() is a static method (special-cased so you need not declare it as such) that takes the class of which an instance was requested as its first argument. The remaining arguments are those passed to the object constructor expression (the call to the class). The return value of __new__() should be the new object instance (usually an instance of cls).

Typical implementations create a new instance of the class by invoking the superclass’s __new__() method using super(currentclass, cls).__new__(cls[, ...]) with appropriate arguments and then modifying the newly-created instance as necessary before returning it.

If __new__() returns an instance of cls, then the new instance’s __init__() method will be invoked like __init__(self[, ...]), where self is the new instance and the remaining arguments are the same as were passed to __new__().

If __new__() does not return an instance of cls, then the new instance’s __init__() method will not be invoked.

__new__() is intended mainly to allow subclasses of immutable types (like int, str, or tuple) to customize instance creation. It is also commonly overridden in custom metaclasses in order to customize class creation. object.__new__(cls[, ...])

type I__next__ ¶

type I__next__ interface {
	M__next__() (Object, error)
}

The next method for iterators

type I__or__ ¶

type I__or__ interface {
	M__or__(other Object) (Object, error)
}

object.__or__(self, other)

type I__pos__ ¶

type I__pos__ interface {
	M__pos__() (Object, error)
}

object.__pos__(self)

type I__pow__ ¶

type I__pow__ interface {
	M__pow__(other, modulo Object) (Object, error)
}

object.__pow__(self, other[, modulo])

type I__radd__ ¶

type I__radd__ interface {
	M__radd__(other Object) (Object, error)
}

object.__radd__(self, other)

type I__rand__ ¶

type I__rand__ interface {
	M__rand__(other Object) (Object, error)
}

object.__rand__(self, other)

type I__rdivmod__ ¶

type I__rdivmod__ interface {
	M__rdivmod__(other Object) (Object, Object, error)
}

object.__rdivmod__(self, other)

type I__repr__ ¶

type I__repr__ interface {
	M__repr__() (Object, error)
}

Called by the repr() built-in function to compute the “official” string representation of an object. If at all possible, this should look like a valid Python expression that could be used to recreate an object with the same value (given an appropriate environment). If this is not possible, a string of the form <...some useful description...> should be returned. The return value must be a string object. If a class defines __repr__() but not __str__(), then __repr__() is also used when an “informal” string representation of instances of that class is required.

This is typically used for debugging, so it is important that the representation is information-rich and unambiguous. object.__repr__(self)

type I__reversed__ ¶

type I__reversed__ interface {
	M__reversed__() (Object, error)
}

Called (if present) by the reversed() built-in to implement reverse iteration. It should return a new iterator object that iterates over all the objects in the container in reverse order.

If the __reversed__() method is not provided, the reversed() built-in will fall back to using the sequence protocol (__len__() and __getitem__()). Objects that support the sequence protocol should only provide __reversed__() if they can provide an implementation that is more efficient than the one provided by reversed(). object.__reversed__(self)

type I__rfloordiv__ ¶

type I__rfloordiv__ interface {
	M__rfloordiv__(other Object) (Object, error)
}

object.__rfloordiv__(self, other)

type I__rlshift__ ¶

type I__rlshift__ interface {
	M__rlshift__(other Object) (Object, error)
}

object.__rlshift__(self, other)

type I__rmod__ ¶

type I__rmod__ interface {
	M__rmod__(other Object) (Object, error)
}

object.__rmod__(self, other)

type I__rmul__ ¶

type I__rmul__ interface {
	M__rmul__(other Object) (Object, error)
}

object.__rmul__(self, other)

type I__ror__ ¶

type I__ror__ interface {
	M__ror__(other Object) (Object, error)
}

object.__ror__(self, other)

type I__round__ ¶

type I__round__ interface {
	M__round__(n Object) (Object, error)
}

object.__round__(self, n)

type I__rpow__ ¶

type I__rpow__ interface {
	M__rpow__(other Object) (Object, error)
}

object.__rpow__(self, other)

type I__rrshift__ ¶

type I__rrshift__ interface {
	M__rrshift__(other Object) (Object, error)
}

object.__rrshift__(self, other)

type I__rshift__ ¶

type I__rshift__ interface {
	M__rshift__(other Object) (Object, error)
}

object.__rshift__(self, other)

type I__rsub__ ¶

type I__rsub__ interface {
	M__rsub__(other Object) (Object, error)
}

object.__rsub__(self, other)

type I__rtruediv__ ¶

type I__rtruediv__ interface {
	M__rtruediv__(other Object) (Object, error)
}

object.__rtruediv__(self, other)

type I__rxor__ ¶

type I__rxor__ interface {
	M__rxor__(other Object) (Object, error)
}

object.__rxor__(self, other)

type I__set__ ¶

type I__set__ interface {
	M__set__(instance, value Object) (Object, error)
}

Called to set the attribute on an instance of the owner class to a new value. object.__set__(self, instance, value)

type I__setattr__ ¶

type I__setattr__ interface {
	M__setattr__(name string, value Object) (Object, error)
}

Called when an attribute assignment is attempted. This is called instead of the normal mechanism (i.e. store the value in the instance dictionary). name is the attribute name, value is the value to be assigned to it.

If __setattr__() wants to assign to an instance attribute, it should call the base class method with the same name, for example, object.__setattr__(self, name, value). object.__setattr__(self, name, value)

type I__setitem__ ¶

type I__setitem__ interface {
	M__setitem__(key, value Object) (Object, error)
}

Called to implement assignment to self[key]. Same note as for __getitem__(). This should only be implemented for mappings if the objects support changes to the values for keys, or if new keys can be added, or for sequences if elements can be replaced. The same exceptions should be raised for improper key values as for the __getitem__() method. object.__setitem__(self, key, value)

type I__str__ ¶

type I__str__ interface {
	M__str__() (Object, error)
}

Called by str(object) and the built-in functions format() and print() to compute the “informal” or nicely printable string representation of an object. The return value must be a string object.

This method differs from object.__repr__() in that there is no expectation that __str__() return a valid Python expression: a more convenient or concise representation can be used.

The default implementation defined by the built-in type object calls object.__repr__(). object.__str__(self)

type I__sub__ ¶

type I__sub__ interface {
	M__sub__(other Object) (Object, error)
}

object.__sub__(self, other)

type I__subclasscheck__ ¶

type I__subclasscheck__ interface {
	M__subclasscheck__(subclass Object) (Object, error)
}

Return true if subclass should be considered a (direct or indirect) subclass of class. If defined, called to implement issubclass(subclass, class). object.__subclasscheck__(self, subclass)

type I__truediv__ ¶

type I__truediv__ interface {
	M__truediv__(other Object) (Object, error)
}

object.__truediv__(self, other)

type I__trunc__ ¶

type I__trunc__ interface {
	M__trunc__() (Object, error)
}

Return the Real value x truncated to an Integral (usually an integer). Delegates to x.__trunc__().

type I__xor__ ¶

type I__xor__ interface {
	M__xor__(other Object) (Object, error)
}

object.__xor__(self, other)

type I_close ¶

type I_close interface {
	Close() (Object, error)
}

type I_generator ¶

type I_generator interface {
	I_iterator
	I_send
	I_throw
	I_close
}

Interface all generators must satisfy

type I_iterator ¶

type I_iterator interface {
	I__iter__
	I__next__
}

Interface all iterators must satisfy

type I_send ¶

type I_send interface {
	Send(value Object) (Object, error)
}

Generator interfaces

type I_throw ¶

type I_throw interface {
	Throw(args Tuple, kwargs StringDict) (Object, error)
}

type InitFunc ¶

type InitFunc func(self Object, args Tuple, kwargs StringDict) error

type Int ¶

type Int int64

func GetInt(obj Object) (Int, error)

func GetLen(obj Object) (Int, error)

func Index(a Object) (Int, error)

func (x Int) GoInt() (int, error)

func (x Int) GoInt64() (int64, error)

func (a Int) M__abs__() (Object, error)

func (a Int) M__add__(other Object) (Object, error)

func (a Int) M__and__(other Object) (Object, error)

func (a Int) M__bool__() (Object, error)

func (a Int) M__ceil__() (Object, error)

func (a Int) M__complex__() (Object, error)

func (a Int) M__divmod__(other Object) (Object, Object, error)

func (a Int) M__eq__(other Object) (Object, error)

func (a Int) M__float__() (Object, error)

func (a Int) M__floor__() (Object, error)

func (a Int) M__floordiv__(other Object) (Object, error)

func (a Int) M__ge__(other Object) (Object, error)

func (a Int) M__gt__(other Object) (Object, error)

func (a Int) M__iadd__(other Object) (Object, error)