<s> """<STR_LIT:U+0020>""" <EOL> import py <EOL> from pypy . interpreter . gateway import interp2app , BuiltinCode <EOL> from pypy . interpreter . argument import Arguments <EOL> from pypy . interpreter . baseobjspace import Wrappable , W_Root , ObjSpace , DescrMismatch <EOL> from pypy . interpreter . error import OperationError <EOL> from pypy . tool . sourcetools import compile2 , func_with_new_name <EOL> from pypy . rlib . objectmodel import instantiate , compute_identity_hash <EOL> from pypy . rlib . jit import hint <EOL> class TypeDef : <EOL> def __init__ ( self , __name , __base = None , ** rawdict ) : <EOL> "<STR_LIT>" <EOL> self . name = __name <EOL> self . base = __base <EOL> self . hasdict = '<STR_LIT>' in rawdict <EOL> self . weakrefable = '<STR_LIT>' in rawdict <EOL> if __base is not None : <EOL> self . hasdict |= __base . hasdict <EOL> self . weakrefable |= __base . weakrefable <EOL> self . rawdict = { } <EOL> self . acceptable_as_base_class = True <EOL> self . fakedcpytype = None <EOL> self . add_entries ( ** rawdict ) <EOL> def add_entries ( self , ** rawdict ) : <EOL> for key , value in rawdict . items ( ) : <EOL> if isinstance ( value , ( interp2app , GetSetProperty ) ) : <EOL> value . name = key <EOL> self . rawdict . update ( rawdict ) <EOL> def _freeze_ ( self ) : <EOL> return True <EOL> def __repr__ ( self ) : <EOL> return "<STR_LIT>" % ( self . __class__ . __name__ , self . name ) <EOL> def default_identity_hash ( space , w_obj ) : <EOL> return space . wrap ( compute_identity_hash ( w_obj ) ) <EOL> def descr__hash__unhashable ( space , w_obj ) : <EOL> typename = space . type ( w_obj ) . getname ( space , '<STR_LIT:?>' ) <EOL> msg = "<STR_LIT>" % ( typename , ) <EOL> raise OperationError ( space . w_TypeError , space . wrap ( msg ) ) <EOL> no_hash_descr = interp2app ( descr__hash__unhashable ) <EOL> def get_unique_interplevel_subclass ( cls , hasdict , wants_slots , needsdel = False , <EOL> weakrefable = False ) : <EOL> "<STR_LIT>" <EOL> if hasattr ( cls , '<STR_LIT>' ) and getattr ( cls , "<STR_LIT>" , False ) : <EOL> needsdel = False <EOL> assert cls . typedef . acceptable_as_base_class <EOL> key = cls , hasdict , wants_slots , needsdel , weakrefable <EOL> try : <EOL> return _subclass_cache [ key ] <EOL> except KeyError : <EOL> subcls = _getusercls ( cls , hasdict , wants_slots , needsdel , weakrefable ) <EOL> _subclass_cache [ key ] = subcls <EOL> return subcls <EOL> get_unique_interplevel_subclass . _annspecialcase_ = "<STR_LIT>" <EOL> _subclass_cache = { } <EOL> def enum_interplevel_subclasses ( cls ) : <EOL> """<STR_LIT>""" <EOL> result = [ ] <EOL> for flag1 in ( False , True ) : <EOL> for flag2 in ( False , True ) : <EOL> for flag3 in ( False , True ) : <EOL> for flag4 in ( False , True ) : <EOL> result . append ( get_unique_interplevel_subclass ( cls , flag1 , <EOL> flag2 , flag3 , <EOL> flag4 ) ) <EOL> result = dict . fromkeys ( result ) <EOL> assert len ( result ) <= <NUM_LIT:6> <EOL> return result . keys ( ) <EOL> def _getusercls ( cls , wants_dict , wants_slots , wants_del , weakrefable ) : <EOL> typedef = cls . typedef <EOL> if wants_dict and typedef . hasdict : <EOL> wants_dict = False <EOL> if wants_del : <EOL> if wants_dict : <EOL> parentcls = get_unique_interplevel_subclass ( cls , True , True , <EOL> False , True ) <EOL> else : <EOL> parentcls = get_unique_interplevel_subclass ( cls , False , True , <EOL> False , True ) <EOL> return _usersubclswithfeature ( parentcls , "<STR_LIT>" ) <EOL> elif wants_dict : <EOL> if wants_slots : <EOL> parentcls = get_unique_interplevel_subclass ( cls , True , False , <EOL> False , True ) <EOL> return _usersubclswithfeature ( parentcls , "<STR_LIT>" ) <EOL> else : <EOL> if not typedef . weakrefable : <EOL> return _usersubclswithfeature ( cls , "<STR_LIT:user>" , "<STR_LIT>" , "<STR_LIT>" ) <EOL> else : <EOL> return _usersubclswithfeature ( cls , "<STR_LIT:user>" , "<STR_LIT>" ) <EOL> else : <EOL> if weakrefable and not typedef . weakrefable : <EOL> parentcls = get_unique_interplevel_subclass ( cls , False , True , <EOL> False , False ) <EOL> return _usersubclswithfeature ( parentcls , "<STR_LIT>" ) <EOL> else : <EOL> return _usersubclswithfeature ( cls , "<STR_LIT:user>" , "<STR_LIT>" ) <EOL> def _usersubclswithfeature ( parentcls , * features ) : <EOL> key = parentcls , features <EOL> try : <EOL> return _usersubclswithfeature_cache [ key ] <EOL> except KeyError : <EOL> subcls = _builduserclswithfeature ( parentcls , * features ) <EOL> _usersubclswithfeature_cache [ key ] = subcls <EOL> return subcls <EOL> _usersubclswithfeature_cache = { } <EOL> _allusersubcls_cache = { } <EOL> def _builduserclswithfeature ( supercls , * features ) : <EOL> "<STR_LIT>" <EOL> name = supercls . __name__ <EOL> name += '<STR_LIT>' . join ( [ name . capitalize ( ) for name in features ] ) <EOL> body = { } <EOL> def add ( Proto ) : <EOL> for key , value in Proto . __dict__ . items ( ) : <EOL> if not key . startswith ( '<STR_LIT>' ) or key == '<STR_LIT>' : <EOL> body [ key ] = value <EOL> if "<STR_LIT:user>" in features : <EOL> class Proto ( object ) : <EOL> def getclass ( self , space ) : <EOL> return hint ( self . w__class__ , promote = True ) <EOL> def setclass ( self , space , w_subtype ) : <EOL> self . w__class__ = w_subtype <EOL> def user_setup ( self , space , w_subtype ) : <EOL> self . space = space <EOL> self . w__class__ = w_subtype <EOL> self . user_setup_slots ( w_subtype . nslots ) <EOL> def user_setup_slots ( self , nslots ) : <EOL> assert nslots == <NUM_LIT:0> <EOL> add ( Proto ) <EOL> if "<STR_LIT>" in features : <EOL> class Proto ( object ) : <EOL> _lifeline_ = None <EOL> def getweakref ( self ) : <EOL> return self . _lifeline_ <EOL> def setweakref ( self , space , weakreflifeline ) : <EOL> self . _lifeline_ = weakreflifeline <EOL> add ( Proto ) <EOL> if "<STR_LIT>" in features : <EOL> class Proto ( object ) : <EOL> def __del__ ( self ) : <EOL> self . _enqueue_for_destruction ( self . space ) <EOL> parent_destructor = getattr ( supercls , '<STR_LIT>' , None ) <EOL> if parent_destructor is not None : <EOL> def _call_builtin_destructor ( self ) : <EOL> parent_destructor ( self ) <EOL> Proto . _call_builtin_destructor = _call_builtin_destructor <EOL> add ( Proto ) <EOL> if "<STR_LIT>" in features : <EOL> class Proto ( object ) : <EOL> slots_w = [ ] <EOL> def user_setup_slots ( self , nslots ) : <EOL> if nslots > <NUM_LIT:0> : <EOL> self . slots_w = [ None ] * nslots <EOL> def setslotvalue ( self , index , w_value ) : <EOL> self . slots_w [ index ] = w_value <EOL> def getslotvalue ( self , index ) : <EOL> return self . slots_w [ index ] <EOL> add ( Proto ) <EOL> if "<STR_LIT>" in features : <EOL> class Proto ( object ) : <EOL> def getdict ( self ) : <EOL> return self . w__dict__ <EOL> def setdict ( self , space , w_dict ) : <EOL> self . w__dict__ = check_new_dictionary ( space , w_dict ) <EOL> def user_setup ( self , space , w_subtype ) : <EOL> self . space = space <EOL> self . w__class__ = w_subtype <EOL> if space . config . objspace . std . withsharingdict : <EOL> from pypy . objspace . std import dictmultiobject <EOL> self . w__dict__ = dictmultiobject . W_DictMultiObject ( space , <EOL> sharing = True ) <EOL> elif space . config . objspace . std . withshadowtracking : <EOL> from pypy . objspace . std import dictmultiobject <EOL> self . w__dict__ = dictmultiobject . W_DictMultiObject ( space ) <EOL> self . w__dict__ . implementation = dictmultiobject . ShadowDetectingDictImplementation ( <EOL> space , w_subtype ) <EOL> else : <EOL> self . w__dict__ = space . newdict ( ) <EOL> self . user_setup_slots ( w_subtype . nslots ) <EOL> def setclass ( self , space , w_subtype ) : <EOL> self . w__class__ = w_subtype <EOL> if space . config . objspace . std . withshadowtracking : <EOL> self . w__dict__ . implementation . set_shadows_anything ( ) <EOL> def getdictvalue_attr_is_in_class ( self , space , w_name ) : <EOL> w_dict = self . w__dict__ <EOL> if space . config . objspace . std . withshadowtracking : <EOL> if not w_dict . implementation . shadows_anything ( ) : <EOL> return None <EOL> return space . finditem ( w_dict , w_name ) <EOL> add ( Proto ) <EOL> subcls = type ( name , ( supercls , ) , body ) <EOL> _allusersubcls_cache [ subcls ] = True <EOL> return subcls <EOL> def check_new_dictionary ( space , w_dict ) : <EOL> if not space . is_true ( space . isinstance ( w_dict , space . w_dict ) ) : <EOL> raise OperationError ( space . w_TypeError , <EOL> space . wrap ( "<STR_LIT>" ) ) <EOL> from pypy . objspace . std import dictmultiobject <EOL> assert isinstance ( w_dict , dictmultiobject . W_DictMultiObject ) <EOL> return w_dict <EOL> check_new_dictionary . _dont_inline_ = True <EOL> def make_descr_typecheck_wrapper ( func , extraargs = ( ) , cls = None ) : <EOL> if func is None : <EOL> return None <EOL> if cls is None : <EOL> return func <EOL> if hasattr ( func , '<STR_LIT>' ) : <EOL> assert func . im_class is cls <EOL> func = func . im_func <EOL> miniglobals = { <EOL> func . __name__ : func , <EOL> '<STR_LIT>' : OperationError <EOL> } <EOL> if isinstance ( cls , str ) : <EOL> assert cls . startswith ( '<STR_LIT:<>' ) , "<STR_LIT>" <EOL> source = """<STR_LIT>""" <EOL> cls_name = cls [ <NUM_LIT:1> : ] <EOL> expected = repr ( cls_name ) <EOL> else : <EOL> cls_name = cls . __name__ <EOL> assert issubclass ( cls , Wrappable ) <EOL> source = """<STR_LIT>""" <EOL> miniglobals [ cls_name ] = cls <EOL> name = func . __name__ <EOL> extra = '<STR_LIT:U+002CU+0020>' . join ( extraargs ) <EOL> source = py . code . Source ( source % locals ( ) ) <EOL> exec source . compile ( ) in miniglobals <EOL> return miniglobals [ '<STR_LIT>' % func . __name__ ] <EOL> def unknown_objclass_getter ( space ) : <EOL> raise OperationError ( space . w_AttributeError , <EOL> space . wrap ( "<STR_LIT>" ) ) <EOL> def make_objclass_getter ( func , cls , cache = { } ) : <EOL> if hasattr ( func , '<STR_LIT>' ) : <EOL> assert not cls or cls is func . im_class <EOL> cls = func . im_class <EOL> if not cls : <EOL> return unknown_objclass_getter , cls <EOL> try : <EOL> return cache [ cls ] <EOL> except KeyError : <EOL> pass <EOL> miniglobals = { } <EOL> if isinstance ( cls , str ) : <EOL> assert cls . startswith ( '<STR_LIT:<>' ) , "<STR_LIT>" <EOL> cls_name = cls [ <NUM_LIT:1> : ] <EOL> typeexpr = "<STR_LIT>" % cls_name <EOL> else : <EOL> miniglobals [ '<STR_LIT>' ] = cls <EOL> typeexpr = "<STR_LIT>" <EOL> source = """<STR_LIT>""" % ( typeexpr , ) <EOL> exec compile2 ( source ) in miniglobals <EOL> res = miniglobals [ '<STR_LIT>' ] , cls <EOL> cache [ cls ] = res <EOL> return res <EOL> class GetSetProperty ( Wrappable ) : <EOL> def __init__ ( self , fget , fset = None , fdel = None , doc = None , cls = None ) : <EOL> "<STR_LIT>" <EOL> objclass_getter , cls = make_objclass_getter ( fget , cls ) <EOL> fget = make_descr_typecheck_wrapper ( fget , cls = cls ) <EOL> fset = make_descr_typecheck_wrapper ( fset , ( '<STR_LIT>' , ) , cls = cls ) <EOL> fdel = make_descr_typecheck_wrapper ( fdel , cls = cls ) <EOL> self . fget = fget <EOL> self . fset = fset <EOL> self . fdel = fdel <EOL> self . doc = doc <EOL> self . reqcls = cls <EOL> self . name = '<STR_LIT>' <EOL> self . objclass_getter = objclass_getter <EOL> def descr_property_get ( space , property , w_obj , w_cls = None ) : <EOL> """<STR_LIT>""" <EOL> if ( space . is_w ( w_obj , space . w_None ) <EOL> and not space . is_w ( w_cls , space . type ( space . w_None ) ) ) : <EOL> return space . wrap ( property ) <EOL> else : <EOL> try : <EOL> return property . fget ( space , w_obj ) <EOL> except DescrMismatch , e : <EOL> return w_obj . descr_call_mismatch ( space , '<STR_LIT>' , property . reqcls , Arguments ( space , [ w_obj , <EOL> space . wrap ( property . name ) ] ) ) <EOL> def descr_property_set ( space , property , w_obj , w_value ) : <EOL> """<STR_LIT>""" <EOL> fset = property . fset <EOL> if fset is None : <EOL> raise OperationError ( space . w_TypeError , <EOL> space . wrap ( "<STR_LIT>" ) ) <EOL> try : <EOL> fset ( space , w_obj , w_value ) <EOL> except DescrMismatch , e : <EOL> w_obj . descr_call_mismatch ( space , '<STR_LIT>' , property . reqcls , Arguments ( space , [ w_obj , <EOL> space . wrap ( property . name ) , w_value ] ) ) <EOL> def descr_property_del ( space , property , w_obj ) : <EOL> """<STR_LIT>""" <EOL> fdel = property . fdel <EOL> if fdel is None : <EOL> raise OperationError ( space . w_AttributeError , <EOL> space . wrap ( "<STR_LIT>" ) ) <EOL> try : <EOL> fdel ( space , w_obj ) <EOL> except DescrMismatch , e : <EOL> w_obj . descr_call_mismatch ( space , '<STR_LIT>' , property . reqcls , Arguments ( space , [ w_obj , <EOL> space . wrap ( property . name ) ] ) ) <EOL> def descr_get_objclass ( space , property ) : <EOL> return property . objclass_getter ( space ) <EOL> def interp_attrproperty ( name , cls , doc = None ) : <EOL> "<STR_LIT>" <EOL> def fget ( space , obj ) : <EOL> return space . wrap ( getattr ( obj , name ) ) <EOL> return GetSetProperty ( fget , cls = cls , doc = doc ) <EOL> def interp_attrproperty_w ( name , cls , doc = None ) : <EOL> "<STR_LIT>" <EOL> def fget ( space , obj ) : <EOL> w_value = getattr ( obj , name ) <EOL> if w_value is None : <EOL> return space . w_None <EOL> else : <EOL> return w_value <EOL> return GetSetProperty ( fget , cls = cls , doc = doc ) <EOL> GetSetProperty . typedef = TypeDef ( <EOL> "<STR_LIT>" , <EOL> __get__ = interp2app ( GetSetProperty . descr_property_get . im_func , <EOL> unwrap_spec = [ ObjSpace , <EOL> GetSetProperty , W_Root , W_Root ] ) , <EOL> __set__ = interp2app ( GetSetProperty . descr_property_set . im_func , <EOL> unwrap_spec = [ ObjSpace , <EOL> GetSetProperty , W_Root , W_Root ] ) , <EOL> __delete__ = interp2app ( GetSetProperty . descr_property_del . im_func , <EOL> unwrap_spec = [ ObjSpace , <EOL> GetSetProperty , W_Root ] ) , <EOL> __name__ = interp_attrproperty ( '<STR_LIT:name>' , cls = GetSetProperty ) , <EOL> __objclass__ = GetSetProperty ( GetSetProperty . descr_get_objclass ) , <EOL> __doc__ = interp_attrproperty ( '<STR_LIT>' , cls = GetSetProperty ) , <EOL> ) <EOL> GetSetProperty . typedef . acceptable_as_base_class = False <EOL> class Member ( Wrappable ) : <EOL> """<STR_LIT>""" <EOL> _immutable_ = True <EOL> def __init__ ( self , index , name , w_cls ) : <EOL> self . index = index <EOL> self . name = name <EOL> self . w_cls = w_cls <EOL> def typecheck ( self , space , w_obj ) : <EOL> if not space . is_true ( space . isinstance ( w_obj , self . w_cls ) ) : <EOL> raise OperationError ( space . w_TypeError , <EOL> space . wrap ( "<STR_LIT>" <EOL> "<STR_LIT>" % <EOL> ( self . name , <EOL> self . w_cls . name , <EOL> space . type ( w_obj ) . getname ( space , '<STR_LIT:?>' ) ) ) ) <EOL> def descr_member_get ( space , member , w_obj , w_w_cls = None ) : <EOL> """<STR_LIT>""" <EOL> if space . is_w ( w_obj , space . w_None ) : <EOL> return space . wrap ( member ) <EOL> else : <EOL> self = member <EOL> self . typecheck ( space , w_obj ) <EOL> w_result = w_obj . getslotvalue ( self . index ) <EOL> if w_result is None : <EOL> raise OperationError ( space . w_AttributeError , <EOL> space . wrap ( self . name ) ) <EOL> return w_result <EOL> def descr_member_set ( space , member , w_obj , w_value ) : <EOL> """<STR_LIT>""" <EOL> self = member <EOL> self . typecheck ( space , w_obj ) <EOL> w_obj . setslotvalue ( self . index , w_value ) <EOL> def descr_member_del ( space , member , w_obj ) : <EOL> """<STR_LIT>""" <EOL> self = member <EOL> self . typecheck ( space , w_obj ) <EOL> w_obj . setslotvalue ( self . index , None ) <EOL> Member . typedef = TypeDef ( <EOL> "<STR_LIT>" , <EOL> __get__ = interp2app ( Member . descr_member_get . im_func , <EOL> unwrap_spec = [ ObjSpace , <EOL> Member , W_Root , W_Root ] ) , <EOL> __set__ = interp2app ( Member . descr_member_set . im_func , <EOL> unwrap_spec = [ ObjSpace , <EOL> Member , W_Root , W_Root ] ) , <EOL> __delete__ = interp2app ( Member . descr_member_del . im_func , <EOL> unwrap_spec = [ ObjSpace , <EOL> Member , W_Root ] ) , <EOL> __name__ = interp_attrproperty ( '<STR_LIT:name>' , cls = Member ) , <EOL> __objclass__ = interp_attrproperty_w ( '<STR_LIT>' , cls = Member ) , <EOL> ) <EOL> Member . typedef . acceptable_as_base_class = False <EOL> from pypy . interpreter . eval import Code , Frame <EOL> from pypy . interpreter . pycode import PyCode , CO_VARARGS , CO_VARKEYWORDS <EOL> from pypy . interpreter . pyframe import PyFrame <EOL> from pypy . interpreter . pyopcode import SuspendedUnroller <EOL> from pypy . interpreter . module import Module <EOL> from pypy . interpreter . function import Function , Method , StaticMethod <EOL> from pypy . interpreter . function import ClassMethod <EOL> from pypy . interpreter . function import BuiltinFunction , descr_function_get <EOL> from pypy . interpreter . pytraceback import PyTraceback <EOL> from pypy . interpreter . generator import GeneratorIterator <EOL> from pypy . interpreter . nestedscope import Cell <EOL> from pypy . interpreter . special import NotImplemented , Ellipsis <EOL> def descr_get_dict ( space , w_obj ) : <EOL> w_dict = w_obj . getdict ( ) <EOL> if w_dict is None : <EOL> typename = space . type ( w_obj ) . getname ( space , '<STR_LIT:?>' ) <EOL> raise OperationError ( space . w_TypeError , <EOL> space . wrap ( "<STR_LIT>" <EOL> "<STR_LIT>" % typename ) ) <EOL> return w_dict <EOL> def descr_set_dict ( space , w_obj , w_dict ) : <EOL> w_obj . setdict ( space , w_dict ) <EOL> def descr_get_weakref ( space , w_obj ) : <EOL> lifeline = w_obj . getweakref ( ) <EOL> if lifeline is None : <EOL> return space . w_None <EOL> return lifeline . get_any_weakref ( space ) <EOL> def generic_ne ( space , w_obj1 , w_obj2 ) : <EOL> if space . eq_w ( w_obj1 , w_obj2 ) : <EOL> return space . w_False <EOL> else : <EOL> return space . w_True <EOL> descr_generic_ne = interp2app ( generic_ne ) <EOL> def fget_co_varnames ( space , code ) : <EOL> return space . newtuple ( [ space . wrap ( name ) for name in code . getvarnames ( ) ] ) <EOL> def fget_co_argcount ( space , code ) : <EOL> return space . wrap ( code . signature ( ) . num_argnames ( ) ) <EOL> def fget_co_flags ( space , code ) : <EOL> sig = code . signature ( ) <EOL> flags = <NUM_LIT:0> <EOL> if sig . has_vararg ( ) : flags |= CO_VARARGS <EOL> if sig . has_kwarg ( ) : flags |= CO_VARKEYWORDS <EOL> return space . wrap ( flags ) <EOL> def fget_co_consts ( space , code ) : <EOL> w_docstring = code . getdocstring ( space ) <EOL> return space . newtuple ( [ w_docstring ] ) <EOL> weakref_descr = GetSetProperty ( descr_get_weakref ) <EOL> weakref_descr . name = '<STR_LIT>' <EOL> def make_weakref_descr ( cls ) : <EOL> """<STR_LIT>""" <EOL> def getweakref ( self ) : <EOL> return self . _lifeline_ <EOL> def setweakref ( self , space , weakreflifeline ) : <EOL> self . _lifeline_ = weakreflifeline <EOL> cls . _lifeline_ = None <EOL> cls . getweakref = getweakref <EOL> cls . setweakref = setweakref <EOL> return weakref_descr <EOL> Code . typedef = TypeDef ( '<STR_LIT>' , <EOL> co_name = interp_attrproperty ( '<STR_LIT>' , cls = Code ) , <EOL> co_varnames = GetSetProperty ( fget_co_varnames , cls = Code ) , <EOL> co_argcount = GetSetProperty ( fget_co_argcount , cls = Code ) , <EOL> co_flags = GetSetProperty ( fget_co_flags , cls = Code ) , <EOL> co_consts = GetSetProperty ( fget_co_consts , cls = Code ) , <EOL> ) <EOL> Code . typedef . acceptable_as_base_class = False <EOL> BuiltinCode . typedef = TypeDef ( '<STR_LIT>' , <EOL> __reduce__ = interp2app ( BuiltinCode . descr__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> co_name = interp_attrproperty ( '<STR_LIT>' , cls = BuiltinCode ) , <EOL> co_varnames = GetSetProperty ( fget_co_varnames , cls = BuiltinCode ) , <EOL> co_argcount = GetSetProperty ( fget_co_argcount , cls = BuiltinCode ) , <EOL> co_flags = GetSetProperty ( fget_co_flags , cls = BuiltinCode ) , <EOL> co_consts = GetSetProperty ( fget_co_consts , cls = BuiltinCode ) , <EOL> ) <EOL> BuiltinCode . typedef . acceptable_as_base_class = False <EOL> Frame . typedef = TypeDef ( '<STR_LIT>' , <EOL> f_code = GetSetProperty ( Frame . fget_code ) , <EOL> f_locals = GetSetProperty ( Frame . fget_getdictscope ) , <EOL> f_globals = interp_attrproperty_w ( '<STR_LIT>' , cls = Frame ) , <EOL> ) <EOL> Frame . typedef . acceptable_as_base_class = False <EOL> PyCode . typedef = TypeDef ( '<STR_LIT:code>' , <EOL> __new__ = interp2app ( PyCode . descr_code__new__ . im_func ) , <EOL> __eq__ = interp2app ( PyCode . descr_code__eq__ ) , <EOL> __ne__ = descr_generic_ne , <EOL> __hash__ = interp2app ( PyCode . descr_code__hash__ ) , <EOL> __reduce__ = interp2app ( PyCode . descr__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __repr__ = interp2app ( PyCode . repr ) , <EOL> co_argcount = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_nlocals = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_stacksize = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_flags = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_code = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_consts = GetSetProperty ( PyCode . fget_co_consts ) , <EOL> co_names = GetSetProperty ( PyCode . fget_co_names ) , <EOL> co_varnames = GetSetProperty ( PyCode . fget_co_varnames ) , <EOL> co_freevars = GetSetProperty ( PyCode . fget_co_freevars ) , <EOL> co_cellvars = GetSetProperty ( PyCode . fget_co_cellvars ) , <EOL> co_filename = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_name = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_firstlineno = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> co_lnotab = interp_attrproperty ( '<STR_LIT>' , cls = PyCode ) , <EOL> ) <EOL> PyCode . typedef . acceptable_as_base_class = False <EOL> PyFrame . typedef = TypeDef ( '<STR_LIT>' , <EOL> __reduce__ = interp2app ( PyFrame . descr__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __setstate__ = interp2app ( PyFrame . descr__setstate__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace , W_Root ] ) , <EOL> f_builtins = GetSetProperty ( PyFrame . fget_f_builtins ) , <EOL> f_lineno = GetSetProperty ( PyFrame . fget_f_lineno , PyFrame . fset_f_lineno ) , <EOL> f_back = GetSetProperty ( PyFrame . fget_f_back ) , <EOL> f_lasti = GetSetProperty ( PyFrame . fget_f_lasti ) , <EOL> f_trace = GetSetProperty ( PyFrame . fget_f_trace , PyFrame . fset_f_trace , <EOL> PyFrame . fdel_f_trace ) , <EOL> f_exc_type = GetSetProperty ( PyFrame . fget_f_exc_type ) , <EOL> f_exc_value = GetSetProperty ( PyFrame . fget_f_exc_value ) , <EOL> f_exc_traceback = GetSetProperty ( PyFrame . fget_f_exc_traceback ) , <EOL> f_restricted = GetSetProperty ( PyFrame . fget_f_restricted ) , <EOL> ** Frame . typedef . rawdict ) <EOL> PyFrame . typedef . acceptable_as_base_class = False <EOL> Module . typedef = TypeDef ( "<STR_LIT>" , <EOL> __new__ = interp2app ( Module . descr_module__new__ . im_func , <EOL> unwrap_spec = [ ObjSpace , W_Root , Arguments ] ) , <EOL> __init__ = interp2app ( Module . descr_module__init__ ) , <EOL> __repr__ = interp2app ( Module . descr_module__repr__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __reduce__ = interp2app ( Module . descr__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __dict__ = GetSetProperty ( descr_get_dict , cls = Module ) , <EOL> __doc__ = '<STR_LIT>' <EOL> ) <EOL> getset_func_doc = GetSetProperty ( Function . fget_func_doc , <EOL> Function . fset_func_doc , <EOL> Function . fdel_func_doc ) <EOL> getset___module__ = GetSetProperty ( Function . fget___module__ , <EOL> Function . fset___module__ , <EOL> Function . fdel___module__ ) <EOL> getset_func_defaults = GetSetProperty ( Function . fget_func_defaults , <EOL> Function . fset_func_defaults , <EOL> Function . fdel_func_defaults ) <EOL> getset_func_code = GetSetProperty ( Function . fget_func_code , <EOL> Function . fset_func_code ) <EOL> getset_func_name = GetSetProperty ( Function . fget_func_name , <EOL> Function . fset_func_name ) <EOL> getset_func_dict = GetSetProperty ( descr_get_dict , descr_set_dict , cls = Function ) <EOL> Function . typedef = TypeDef ( "<STR_LIT>" , <EOL> __new__ = interp2app ( Function . descr_function__new__ . im_func ) , <EOL> __call__ = interp2app ( Function . descr_function_call , <EOL> unwrap_spec = [ '<STR_LIT>' , Arguments ] , <EOL> descrmismatch = '<STR_LIT>' ) , <EOL> __get__ = interp2app ( descr_function_get ) , <EOL> __repr__ = interp2app ( Function . descr_function_repr , descrmismatch = '<STR_LIT>' ) , <EOL> __reduce__ = interp2app ( Function . descr_function__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __setstate__ = interp2app ( Function . descr_function__setstate__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace , W_Root ] ) , <EOL> func_code = getset_func_code , <EOL> func_doc = getset_func_doc , <EOL> func_name = getset_func_name , <EOL> func_dict = getset_func_dict , <EOL> func_defaults = getset_func_defaults , <EOL> func_globals = interp_attrproperty_w ( '<STR_LIT>' , cls = Function ) , <EOL> func_closure = GetSetProperty ( Function . fget_func_closure ) , <EOL> __doc__ = getset_func_doc , <EOL> __name__ = getset_func_name , <EOL> __dict__ = getset_func_dict , <EOL> __module__ = getset___module__ , <EOL> __weakref__ = make_weakref_descr ( Function ) , <EOL> ) <EOL> Function . typedef . acceptable_as_base_class = False <EOL> Method . typedef = TypeDef ( "<STR_LIT>" , <EOL> __new__ = interp2app ( Method . descr_method__new__ . im_func ) , <EOL> __call__ = interp2app ( Method . descr_method_call , <EOL> unwrap_spec = [ '<STR_LIT>' , Arguments ] ) , <EOL> __get__ = interp2app ( Method . descr_method_get ) , <EOL> im_func = interp_attrproperty_w ( '<STR_LIT>' , cls = Method ) , <EOL> im_self = interp_attrproperty_w ( '<STR_LIT>' , cls = Method ) , <EOL> im_class = interp_attrproperty_w ( '<STR_LIT>' , cls = Method ) , <EOL> __getattribute__ = interp2app ( Method . descr_method_getattribute ) , <EOL> __eq__ = interp2app ( Method . descr_method_eq ) , <EOL> __ne__ = descr_generic_ne , <EOL> __hash__ = interp2app ( Method . descr_method_hash ) , <EOL> __repr__ = interp2app ( Method . descr_method_repr ) , <EOL> __reduce__ = interp2app ( Method . descr_method__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __weakref__ = make_weakref_descr ( Method ) , <EOL> ) <EOL> Method . typedef . acceptable_as_base_class = False <EOL> StaticMethod . typedef = TypeDef ( "<STR_LIT>" , <EOL> __doc__ = """<STR_LIT>""" , <EOL> __get__ = interp2app ( StaticMethod . descr_staticmethod_get ) , <EOL> __new__ = interp2app ( StaticMethod . descr_staticmethod__new__ . im_func , <EOL> unwrap_spec = [ ObjSpace , W_Root , W_Root ] ) , <EOL> ) <EOL> ClassMethod . typedef = TypeDef ( <EOL> '<STR_LIT>' , <EOL> __new__ = interp2app ( ClassMethod . descr_classmethod__new__ . im_func , <EOL> unwrap_spec = [ ObjSpace , W_Root , W_Root ] ) , <EOL> __get__ = interp2app ( ClassMethod . descr_classmethod_get , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace , W_Root , W_Root ] ) , <EOL> __doc__ = """<STR_LIT>""" , <EOL> ) <EOL> def always_none ( self , obj ) : <EOL> return None <EOL> BuiltinFunction . typedef = TypeDef ( "<STR_LIT>" , ** Function . typedef . rawdict ) <EOL> BuiltinFunction . typedef . rawdict . update ( { <EOL> '<STR_LIT>' : interp2app ( BuiltinFunction . descr_builtinfunction__new__ . im_func ) , <EOL> '<STR_LIT>' : GetSetProperty ( always_none , cls = BuiltinFunction ) , <EOL> '<STR_LIT>' : interp2app ( BuiltinFunction . descr_function_repr ) , <EOL> } ) <EOL> del BuiltinFunction . typedef . rawdict [ '<STR_LIT>' ] <EOL> BuiltinFunction . typedef . acceptable_as_base_class = False <EOL> PyTraceback . typedef = TypeDef ( "<STR_LIT>" , <EOL> __reduce__ = interp2app ( PyTraceback . descr__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __setstate__ = interp2app ( PyTraceback . descr__setstate__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace , W_Root ] ) , <EOL> tb_frame = interp_attrproperty ( '<STR_LIT>' , cls = PyTraceback ) , <EOL> tb_lasti = interp_attrproperty ( '<STR_LIT>' , cls = PyTraceback ) , <EOL> tb_lineno = interp_attrproperty ( '<STR_LIT>' , cls = PyTraceback ) , <EOL> tb_next = interp_attrproperty ( '<STR_LIT>' , cls = PyTraceback ) , <EOL> ) <EOL> PyTraceback . typedef . acceptable_as_base_class = False <EOL> GeneratorIterator . typedef = TypeDef ( "<STR_LIT>" , <EOL> __reduce__ = interp2app ( GeneratorIterator . descr__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> next = interp2app ( GeneratorIterator . descr_next , <EOL> descrmismatch = '<STR_LIT>' ) , <EOL> send = interp2app ( GeneratorIterator . descr_send , <EOL> descrmismatch = '<STR_LIT>' ) , <EOL> throw = interp2app ( GeneratorIterator . descr_throw , <EOL> descrmismatch = '<STR_LIT>' ) , <EOL> close = interp2app ( GeneratorIterator . descr_close , <EOL> descrmismatch = '<STR_LIT>' ) , <EOL> __iter__ = interp2app ( GeneratorIterator . descr__iter__ , <EOL> descrmismatch = '<STR_LIT>' ) , <EOL> __del__ = interp2app ( GeneratorIterator . descr__del__ , <EOL> descrmismatch = '<STR_LIT>' ) , <EOL> gi_running = interp_attrproperty ( '<STR_LIT>' , cls = GeneratorIterator ) , <EOL> gi_frame = GetSetProperty ( GeneratorIterator . descr_gi_frame ) , <EOL> __weakref__ = make_weakref_descr ( GeneratorIterator ) , <EOL> ) <EOL> GeneratorIterator . typedef . acceptable_as_base_class = False <EOL> Cell . typedef = TypeDef ( "<STR_LIT>" , <EOL> __eq__ = interp2app ( Cell . descr__eq__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace , W_Root ] ) , <EOL> __ne__ = descr_generic_ne , <EOL> __hash__ = no_hash_descr , <EOL> __reduce__ = interp2app ( Cell . descr__reduce__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace ] ) , <EOL> __setstate__ = interp2app ( Cell . descr__setstate__ , <EOL> unwrap_spec = [ '<STR_LIT>' , ObjSpace , W_Root ] ) , <EOL> cell_contents = GetSetProperty ( Cell . descr__cell_contents , cls = Cell ) , <EOL> ) <EOL> Cell . typedef . acceptable_as_base_class = False <EOL> Ellipsis . typedef = TypeDef ( "<STR_LIT>" , <EOL> __repr__ = interp2app ( Ellipsis . descr__repr__ ) , <EOL> ) <EOL> Ellipsis . typedef . acceptable_as_base_class = False <EOL> NotImplemented . typedef = TypeDef ( "<STR_LIT>" , <EOL> __repr__ = interp2app ( NotImplemented . descr__repr__ ) , <EOL> ) <EOL> NotImplemented . typedef . acceptable_as_base_class = False <EOL> SuspendedUnroller . typedef = TypeDef ( "<STR_LIT>" ) <EOL> SuspendedUnroller . typedef . acceptable_as_base_class = False <EOL> interptypes = [ val . typedef for name , val in globals ( ) . items ( ) if hasattr ( val , '<STR_LIT>' ) and hasattr ( val , '<STR_LIT>' ) ] </s>
