six Namespace Reference

Classes
class	_LazyDescr
class	_LazyModule
class	_MovedItems
class	_SixMetaPathImporter
class	Iterator
class	Module_six_moves_urllib
class	Module_six_moves_urllib_error
class	Module_six_moves_urllib_parse
class	Module_six_moves_urllib_request
class	Module_six_moves_urllib_response
class	Module_six_moves_urllib_robotparser
class	MovedAttribute
class	MovedModule
class	X

Functions
def	add_move (move)
def	remove_move (name)
def	advance_iterator (it)
def	callable (obj)
def	get_unbound_function (unbound)
def	create_unbound_method (func, cls)
def	create_bound_method (func, obj)
def	iterkeys (d, kw)
def	itervalues (d, kw)
def	iteritems (d, kw)
def	iterlists (d, kw)
def	b (s)
def	u (s)
def	byte2int (bs)
def	indexbytes (buf, i)
def	assertCountEqual (self, args, kwargs)
def	assertRaisesRegex (self, args, kwargs)
def	assertRegex (self, args, kwargs)
def	reraise (tp, value, tb=None)
def	exec_ (_code_, _globs_=None, _locs_=None)
def	raise_from (value, from_value)
def	print_ (args, kwargs)
def	wraps (wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, updated=functools.WRAPPER_UPDATES)
def	with_metaclass (meta, bases)
def	add_metaclass (metaclass)
def	python_2_unicode_compatible (klass)

Variables
int	PY2 = 2
int	PY3 = 3
tuple	PY34 = (3, 4)
	string_types = str,
	integer_types = int,
	class_types = type,
	text_type = str
	binary_type = bytes
	MAXSIZE = sys.maxsize
	moves = _MovedItems(__name__ + ".moves")
	advance_iterator = next
	next = advance_iterator
	callable = callable
	create_bound_method = types.MethodType
	Iterator = object
	get_method_function = operator.attrgetter(_meth_func)
	get_method_self = operator.attrgetter(_meth_self)
	get_function_closure = operator.attrgetter(_func_closure)
	get_function_code = operator.attrgetter(_func_code)
	get_function_defaults = operator.attrgetter(_func_defaults)
	get_function_globals = operator.attrgetter(_func_globals)
	viewkeys = operator.methodcaller("keys")
	viewvalues = operator.methodcaller("values")
	viewitems = operator.methodcaller("items")
	unichr = chr
	int2byte = struct.Struct(">B").pack
	byte2int = operator.itemgetter(0)
	indexbytes = operator.getitem
	iterbytes = iter
	StringIO = io.StringIO
	BytesIO = io.BytesIO
	exec_ = getattr(moves.builtins, "exec")
	print_ = getattr(moves.builtins, "print", None)
def	wraps = functools.wraps
	submodule_search_locations

Detailed Description

Utilities for writing code that runs on Python 2 and 3

Function Documentation

add_metaclass()

def six.add_metaclass

(

metaclass

)

Class decorator for creating a class with a metaclass.

add_move()

def six.add_move

(

move

)

Add an item to six.moves.

advance_iterator()

def six.advance_iterator

(

it

)

assertCountEqual()

def six.assertCountEqual	(		self,
			args,
			kwargs
	)

assertRaisesRegex()

def six.assertRaisesRegex	(		self,
			args,
			kwargs
	)

assertRegex()

def six.assertRegex	(		self,
			args,
			kwargs
	)

b()

def six.b

(

s

)

byte2int()

def six.byte2int

(

bs

)

callable()

def six.callable

(

obj

)

create_bound_method()

def six.create_bound_method	(		func,
			obj
	)

create_unbound_method()

def six.create_unbound_method	(		func,
			cls
	)

exec_()

def six.exec_	(		_code_,
			_globs_ = None,
			_locs_ = None
	)

Execute code in a namespace.

get_unbound_function()

def six.get_unbound_function

(

unbound

)

indexbytes()

def six.indexbytes	(		buf,
			i
	)

iteritems()

def six.iteritems	(		d,
			kw
	)

iterkeys()

def six.iterkeys	(		d,
			kw
	)

iterlists()

def six.iterlists	(		d,
			kw
	)

itervalues()

def six.itervalues	(		d,
			kw
	)

print_()

def six.print_	(		args,
			kwargs
	)

The new-style print function for Python 2.4 and 2.5.

python_2_unicode_compatible()

def six.python_2_unicode_compatible

(

klass

)

A decorator that defines __unicode__ and __str__ methods under Python 2.
Under Python 3 it does nothing.

To support Python 2 and 3 with a single code base, define a __str__ method
returning text and apply this decorator to the class.

raise_from()

def six.raise_from	(		value,
			from_value
	)

remove_move()

def six.remove_move

(

name

)

Remove item from six.moves.

reraise()

def six.reraise	(		tp,
			value,
			tb = None
	)

u()

def six.u

(

s

)

with_metaclass()

def six.with_metaclass	(		meta,
			bases
	)

Create a base class with a metaclass.

wraps()

def six.wraps	(		wrapped,
			assigned = functools.WRAPPER_ASSIGNMENTS,
			updated = functools.WRAPPER_UPDATES
	)

Variable Documentation

advance_iterator

six.advance_iterator = next

binary_type

six.binary_type = bytes

byte2int

six.byte2int = operator.itemgetter(0)

BytesIO

six.BytesIO = io.BytesIO

callable

six.callable = callable

class_types

tuple six.class_types = type,

create_bound_method

six.create_bound_method = types.MethodType

exec_

six.exec_ = getattr(moves.builtins, "exec")

get_function_closure

six.get_function_closure = operator.attrgetter(_func_closure)

get_function_code

six.get_function_code = operator.attrgetter(_func_code)

get_function_defaults

six.get_function_defaults = operator.attrgetter(_func_defaults)

get_function_globals

six.get_function_globals = operator.attrgetter(_func_globals)

get_method_function

six.get_method_function = operator.attrgetter(_meth_func)

get_method_self

six.get_method_self = operator.attrgetter(_meth_self)

indexbytes

six.indexbytes = operator.getitem

int2byte

six.int2byte = struct.Struct(">B").pack

integer_types

tuple six.integer_types = int,

Iterator

six.Iterator = object

iterbytes

six.iterbytes = iter

MAXSIZE

six.MAXSIZE = sys.maxsize

moves

six.moves = _MovedItems(__name__ + ".moves")

next

six.next = advance_iterator

print_

def six.print_ = getattr(moves.builtins, "print", None)

PY2

int six.PY2 = 2

PY3

int six.PY3 = 3

PY34

tuple six.PY34 = (3, 4)

string_types

six.string_types = str,

StringIO

six.StringIO = io.StringIO

submodule_search_locations

six.submodule_search_locations

text_type

six.text_type = str

unichr

six.unichr = chr

viewitems

six.viewitems = operator.methodcaller("items")

viewkeys

six.viewkeys = operator.methodcaller("keys")

viewvalues

six.viewvalues = operator.methodcaller("values")

wraps

def six.wraps = functools.wraps