mirror of https://github.com/morpheus65535/bazarr
118 lines
3.3 KiB
Python
118 lines
3.3 KiB
Python
"""
|
|
An object subclass for Python 2 that gives new-style classes written in the
|
|
style of Python 3 (with ``__next__`` and unicode-returning ``__str__`` methods)
|
|
the appropriate Python 2-style ``next`` and ``__unicode__`` methods for compatible.
|
|
|
|
Example use::
|
|
|
|
from builtins import object
|
|
|
|
my_unicode_str = u'Unicode string: \u5b54\u5b50'
|
|
|
|
class A(object):
|
|
def __str__(self):
|
|
return my_unicode_str
|
|
|
|
a = A()
|
|
print(str(a))
|
|
|
|
# On Python 2, these relations hold:
|
|
assert unicode(a) == my_unicode_string
|
|
assert str(a) == my_unicode_string.encode('utf-8')
|
|
|
|
|
|
Another example::
|
|
|
|
from builtins import object
|
|
|
|
class Upper(object):
|
|
def __init__(self, iterable):
|
|
self._iter = iter(iterable)
|
|
def __next__(self): # note the Py3 interface
|
|
return next(self._iter).upper()
|
|
def __iter__(self):
|
|
return self
|
|
|
|
assert list(Upper('hello')) == list('HELLO')
|
|
|
|
"""
|
|
|
|
|
|
class newobject(object):
|
|
"""
|
|
A magical object class that provides Python 2 compatibility methods::
|
|
next
|
|
__unicode__
|
|
__nonzero__
|
|
|
|
Subclasses of this class can merely define the Python 3 methods (__next__,
|
|
__str__, and __bool__).
|
|
"""
|
|
def next(self):
|
|
if hasattr(self, '__next__'):
|
|
return type(self).__next__(self)
|
|
raise TypeError('newobject is not an iterator')
|
|
|
|
def __unicode__(self):
|
|
# All subclasses of the builtin object should have __str__ defined.
|
|
# Note that old-style classes do not have __str__ defined.
|
|
if hasattr(self, '__str__'):
|
|
s = type(self).__str__(self)
|
|
else:
|
|
s = str(self)
|
|
if isinstance(s, unicode):
|
|
return s
|
|
else:
|
|
return s.decode('utf-8')
|
|
|
|
def __nonzero__(self):
|
|
if hasattr(self, '__bool__'):
|
|
return type(self).__bool__(self)
|
|
if hasattr(self, '__len__'):
|
|
return type(self).__len__(self)
|
|
# object has no __nonzero__ method
|
|
return True
|
|
|
|
# Are these ever needed?
|
|
# def __div__(self):
|
|
# return self.__truediv__()
|
|
|
|
# def __idiv__(self, other):
|
|
# return self.__itruediv__(other)
|
|
|
|
def __long__(self):
|
|
if not hasattr(self, '__int__'):
|
|
return NotImplemented
|
|
return self.__int__() # not type(self).__int__(self)
|
|
|
|
# def __new__(cls, *args, **kwargs):
|
|
# """
|
|
# dict() -> new empty dictionary
|
|
# dict(mapping) -> new dictionary initialized from a mapping object's
|
|
# (key, value) pairs
|
|
# dict(iterable) -> new dictionary initialized as if via:
|
|
# d = {}
|
|
# for k, v in iterable:
|
|
# d[k] = v
|
|
# dict(**kwargs) -> new dictionary initialized with the name=value pairs
|
|
# in the keyword argument list. For example: dict(one=1, two=2)
|
|
# """
|
|
|
|
# if len(args) == 0:
|
|
# return super(newdict, cls).__new__(cls)
|
|
# elif type(args[0]) == newdict:
|
|
# return args[0]
|
|
# else:
|
|
# value = args[0]
|
|
# return super(newdict, cls).__new__(cls, value)
|
|
|
|
def __native__(self):
|
|
"""
|
|
Hook for the future.utils.native() function
|
|
"""
|
|
return object(self)
|
|
|
|
__slots__ = []
|
|
|
|
__all__ = ['newobject']
|