Gecko [ paroquia-rio-de-mouro.pt ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2018-02-22 00:25
__init__.py	6.68 KB	-rw-r--r--	2014-11-21 12:52
newbytes.py	14.56 KB	-rw-r--r--	2015-07-25 12:34
newdict.py	3.04 KB	-rw-r--r--	2014-11-21 12:52
newint.py	12.92 KB	-rw-r--r--	2015-07-25 12:34
newlist.py	2.23 KB	-rw-r--r--	2014-11-21 12:52
newmemoryview.py	654 B	-rw-r--r--	2014-11-21 12:52
newobject.py	3.65 KB	-rw-r--r--	2014-11-21 12:52
newopen.py	811 B	-rw-r--r--	2014-11-21 12:52
newrange.py	4.92 KB	-rw-r--r--	2015-09-11 09:22
newstr.py	14.83 KB	-rw-r--r--	2014-11-21 12:52

Rename

"""
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')

"""

import sys

from future.utils import with_metaclass

_builtin_object = object
ver = sys.version_info[:2]

# We no longer define a metaclass for newobject because this breaks multiple
# inheritance and custom metaclass use with this exception:

# TypeError: Error when calling the metaclass bases
#     metaclass conflict: the metaclass of a derived class must be a
#     (non-strict) subclass of the metaclasses of all its bases

# See issues #91 and #96.

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)
        # 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)

__all__ = ['newobject']