<s> """<STR_LIT>""" <EOL> from __future__ import print_function <EOL> from __future__ import absolute_import <EOL> import sys <EOL> import copy <EOL> import warnings <EOL> import numpy <EOL> from . import atom <EOL> from . path import check_name_validity <EOL> import six <EOL> from six . moves import zip <EOL> __docformat__ = '<STR_LIT>' <EOL> """<STR_LIT>""" <EOL> def same_position ( oldmethod ) : <EOL> """<STR_LIT>""" <EOL> def newmethod ( self , other ) : <EOL> try : <EOL> other . _v_pos <EOL> except AttributeError : <EOL> return False <EOL> return self . _v_pos == other . _v_pos and oldmethod ( self , other ) <EOL> newmethod . __name__ = oldmethod . __name__ <EOL> newmethod . __doc__ = oldmethod . __doc__ <EOL> return newmethod <EOL> class Col ( six . with_metaclass ( type , atom . Atom ) ) : <EOL> """<STR_LIT>""" <EOL> _class_from_prefix = { } <EOL> """<STR_LIT>""" <EOL> @ classmethod <EOL> def prefix ( class_ ) : <EOL> """<STR_LIT>""" <EOL> cname = class_ . __name__ <EOL> return cname [ : cname . rfind ( '<STR_LIT>' ) ] <EOL> @ classmethod <EOL> def from_atom ( class_ , atom , pos = None ) : <EOL> """<STR_LIT>""" <EOL> prefix = atom . prefix ( ) <EOL> kwargs = atom . _get_init_args ( ) <EOL> colclass = class_ . _class_from_prefix [ prefix ] <EOL> return colclass ( pos = pos , ** kwargs ) <EOL> @ classmethod <EOL> def from_sctype ( class_ , sctype , shape = ( ) , dflt = None , pos = None ) : <EOL> """<STR_LIT>""" <EOL> newatom = atom . Atom . from_sctype ( sctype , shape , dflt ) <EOL> return class_ . from_atom ( newatom , pos = pos ) <EOL> @ classmethod <EOL> def from_dtype ( class_ , dtype , dflt = None , pos = None ) : <EOL> """<STR_LIT>""" <EOL> newatom = atom . Atom . from_dtype ( dtype , dflt ) <EOL> return class_ . from_atom ( newatom , pos = pos ) <EOL> @ classmethod <EOL> def from_type ( class_ , type , shape = ( ) , dflt = None , pos = None ) : <EOL> """<STR_LIT>""" <EOL> newatom = atom . Atom . from_type ( type , shape , dflt ) <EOL> return class_ . from_atom ( newatom , pos = pos ) <EOL> @ classmethod <EOL> def from_kind ( class_ , kind , itemsize = None , shape = ( ) , dflt = None , pos = None ) : <EOL> """<STR_LIT>""" <EOL> newatom = atom . Atom . from_kind ( kind , itemsize , shape , dflt ) <EOL> return class_ . from_atom ( newatom , pos = pos ) <EOL> @ classmethod <EOL> def _subclass_from_prefix ( class_ , prefix ) : <EOL> """<STR_LIT>""" <EOL> cname = '<STR_LIT>' % prefix <EOL> class_from_prefix = class_ . _class_from_prefix <EOL> if cname in class_from_prefix : <EOL> return class_from_prefix [ cname ] <EOL> atombase = getattr ( atom , '<STR_LIT>' % prefix ) <EOL> class NewCol ( class_ , atombase ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , * args , ** kwargs ) : <EOL> pos = kwargs . pop ( '<STR_LIT>' , None ) <EOL> class_from_prefix = self . _class_from_prefix <EOL> atombase . __init__ ( self , * args , ** kwargs ) <EOL> if self . __class__ is not NewCol : <EOL> colclass = class_from_prefix [ self . prefix ( ) ] <EOL> self . __class__ = colclass <EOL> self . _v_pos = pos <EOL> __eq__ = same_position ( atombase . __eq__ ) <EOL> _is_equal_to_atom = same_position ( atombase . _is_equal_to_atom ) <EOL> if prefix == '<STR_LIT>' : <EOL> _is_equal_to_enumatom = same_position ( <EOL> atombase . _is_equal_to_enumatom ) <EOL> NewCol . __name__ = cname <EOL> class_from_prefix [ prefix ] = NewCol <EOL> return NewCol <EOL> def __repr__ ( self ) : <EOL> atomrepr = super ( Col , self ) . __repr__ ( ) <EOL> lpar = atomrepr . index ( '<STR_LIT:(>' ) <EOL> rpar = atomrepr . rindex ( '<STR_LIT:)>' ) <EOL> atomargs = atomrepr [ lpar + <NUM_LIT:1> : rpar ] <EOL> classname = self . __class__ . __name__ <EOL> return '<STR_LIT>' % ( classname , atomargs , self . _v_pos ) <EOL> def _get_init_args ( self ) : <EOL> """<STR_LIT>""" <EOL> kwargs = dict ( ( arg , getattr ( self , arg ) ) for arg in ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> kwargs [ '<STR_LIT>' ] = getattr ( self , '<STR_LIT>' , None ) <EOL> return kwargs <EOL> def _generate_col_classes ( ) : <EOL> """<STR_LIT>""" <EOL> cprefixes = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> for ( kind , kdata ) in six . iteritems ( atom . atom_map ) : <EOL> if hasattr ( kdata , '<STR_LIT>' ) : <EOL> atomclass = kdata <EOL> cprefixes . append ( atomclass . prefix ( ) ) <EOL> else : <EOL> for atomclass in six . itervalues ( kdata ) : <EOL> cprefixes . append ( atomclass . prefix ( ) ) <EOL> cprefixes . extend ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> if hasattr ( atom , '<STR_LIT>' ) : <EOL> cprefixes . append ( '<STR_LIT>' ) <EOL> if hasattr ( atom , '<STR_LIT>' ) : <EOL> cprefixes . append ( '<STR_LIT>' ) <EOL> for cprefix in cprefixes : <EOL> newclass = Col . _subclass_from_prefix ( cprefix ) <EOL> yield newclass <EOL> StringCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> BoolCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> EnumCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> IntCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Int8Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Int16Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Int32Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Int64Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> UIntCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> UInt8Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> UInt16Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> UInt32Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> UInt64Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> FloatCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> if hasattr ( atom , '<STR_LIT>' ) : <EOL> Float16Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Float32Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Float64Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> if hasattr ( atom , '<STR_LIT>' ) : <EOL> Float96Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> if hasattr ( atom , '<STR_LIT>' ) : <EOL> Float128Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> ComplexCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Complex32Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Complex64Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Complex128Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> if hasattr ( atom , '<STR_LIT>' ) : <EOL> Complex192Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> if hasattr ( atom , '<STR_LIT>' ) : <EOL> Complex256Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> TimeCol = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Time32Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> Time64Col = Col . _subclass_from_prefix ( '<STR_LIT>' ) <EOL> class Description ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , classdict , nestedlvl = - <NUM_LIT:1> , validate = True ) : <EOL> if not classdict : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> newdict = self . __dict__ <EOL> newdict [ "<STR_LIT>" ] = "<STR_LIT:/>" <EOL> newdict [ "<STR_LIT>" ] = [ ] <EOL> newdict [ "<STR_LIT>" ] = { } <EOL> newdict [ "<STR_LIT>" ] = { } <EOL> newdict [ "<STR_LIT>" ] = { } <EOL> newdict [ "<STR_LIT>" ] = { } <EOL> newdict [ "<STR_LIT>" ] = False <EOL> nestedFormats = [ ] <EOL> nestedDType = [ ] <EOL> if not hasattr ( newdict , "<STR_LIT>" ) : <EOL> newdict [ "<STR_LIT>" ] = nestedlvl + <NUM_LIT:1> <EOL> cols_with_pos = [ ] <EOL> cols_no_pos = [ ] <EOL> for ( name , descr ) in six . iteritems ( classdict ) : <EOL> if name . startswith ( '<STR_LIT>' ) : <EOL> if name in newdict : <EOL> warnings . warn ( "<STR_LIT>" <EOL> % ( name , self ) ) <EOL> else : <EOL> newdict [ name ] = descr <EOL> continue <EOL> columns = None <EOL> if ( type ( descr ) == type ( IsDescription ) and <EOL> issubclass ( descr , IsDescription ) ) : <EOL> columns = descr ( ) . columns <EOL> elif ( type ( descr . __class__ ) == type ( IsDescription ) and <EOL> issubclass ( descr . __class__ , IsDescription ) ) : <EOL> columns = descr . columns <EOL> elif isinstance ( descr , dict ) : <EOL> columns = descr <EOL> else : <EOL> descr = copy . copy ( descr ) <EOL> if columns is not None : <EOL> descr = Description ( copy . copy ( columns ) , self . _v_nestedlvl ) <EOL> classdict [ name ] = descr <EOL> pos = getattr ( descr , '<STR_LIT>' , None ) <EOL> if pos is None : <EOL> cols_no_pos . append ( name ) <EOL> else : <EOL> cols_with_pos . append ( ( pos , name ) ) <EOL> cols_with_pos . sort ( ) <EOL> cols_no_pos . sort ( ) <EOL> keys = [ name for ( pos , name ) in cols_with_pos ] + cols_no_pos <EOL> pos = <NUM_LIT:0> <EOL> for k in keys : <EOL> if validate : <EOL> check_name_validity ( k ) <EOL> object = classdict [ k ] <EOL> newdict [ k ] = object <EOL> if not ( isinstance ( object , Col ) or <EOL> isinstance ( object , Description ) ) : <EOL> raise TypeError ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % object ) <EOL> object . _v_pos = pos <EOL> object . _v_parent = self <EOL> pos += <NUM_LIT:1> <EOL> newdict [ '<STR_LIT>' ] [ k ] = object <EOL> newdict [ '<STR_LIT>' ] . append ( k ) <EOL> object . __dict__ [ '<STR_LIT>' ] = k <EOL> if not isinstance ( k , str ) : <EOL> if sys . version_info [ <NUM_LIT:0> ] < <NUM_LIT:3> : <EOL> kk = k . encode ( ) <EOL> else : <EOL> kk = k . decode ( ) <EOL> else : <EOL> kk = k <EOL> if isinstance ( object , Col ) : <EOL> dtype = object . dtype <EOL> newdict [ '<STR_LIT>' ] [ k ] = dtype <EOL> newdict [ '<STR_LIT>' ] [ k ] = object . type <EOL> newdict [ '<STR_LIT>' ] [ k ] = object . dflt <EOL> nestedFormats . append ( object . recarrtype ) <EOL> baserecarrtype = dtype . base . str [ <NUM_LIT:1> : ] <EOL> nestedDType . append ( ( kk , baserecarrtype , dtype . shape ) ) <EOL> else : <EOL> nestedFormats . append ( object . _v_nested_formats ) <EOL> nestedDType . append ( ( kk , object . _v_dtype ) ) <EOL> newdict [ '<STR_LIT>' ] = nestedFormats <EOL> newdict [ '<STR_LIT>' ] = numpy . dtype ( nestedDType ) <EOL> newdict [ '<STR_LIT>' ] = newdict [ '<STR_LIT>' ] . itemsize <EOL> if self . _v_nestedlvl == <NUM_LIT:0> : <EOL> self . _g_set_nested_names_descr ( ) <EOL> self . _g_set_path_names ( ) <EOL> if hasattr ( self , "<STR_LIT>" ) : <EOL> raise ValueError ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> def _g_set_nested_names_descr ( self ) : <EOL> """<STR_LIT>""" <EOL> names = self . _v_names <EOL> fmts = self . _v_nested_formats <EOL> self . _v_nested_names = names [ : ] <EOL> self . _v_nested_descr = list ( zip ( names , fmts ) ) <EOL> for i , name in enumerate ( names ) : <EOL> new_object = self . _v_colobjects [ name ] <EOL> if isinstance ( new_object , Description ) : <EOL> new_object . _g_set_nested_names_descr ( ) <EOL> self . _v_nested_names [ i ] = ( name , new_object . _v_nested_names ) <EOL> self . _v_nested_descr [ i ] = ( name , new_object . _v_nested_descr ) <EOL> self . _v_is_nested = True <EOL> def _g_set_path_names ( self ) : <EOL> """<STR_LIT>""" <EOL> def get_cols_in_order ( description ) : <EOL> return [ description . _v_colobjects [ colname ] <EOL> for colname in description . _v_names ] <EOL> def join_paths ( path1 , path2 ) : <EOL> if not path1 : <EOL> return path2 <EOL> return '<STR_LIT>' % ( path1 , path2 ) <EOL> stack = [ ] <EOL> self . _v_pathname = '<STR_LIT>' <EOL> stack . append ( ( self , get_cols_in_order ( self ) ) ) <EOL> while stack : <EOL> desc , cols = stack . pop ( ) <EOL> head = cols [ <NUM_LIT:0> ] <EOL> if isinstance ( head , Description ) : <EOL> head . _v_pathname = join_paths ( desc . _v_pathname , head . _v_name ) <EOL> stack . append ( ( desc , cols [ <NUM_LIT:1> : ] ) ) <EOL> stack . append ( ( head , get_cols_in_order ( head ) ) ) <EOL> elif isinstance ( head , Col ) : <EOL> head . _v_pathname = join_paths ( desc . _v_pathname , head . _v_name ) <EOL> cols . append ( head . _v_name ) <EOL> stack . append ( ( desc , cols [ <NUM_LIT:1> : ] ) ) <EOL> else : <EOL> assert isinstance ( head , six . string_types ) <EOL> desc . _v_pathnames = cols <EOL> if len ( stack ) > <NUM_LIT:0> : <EOL> descName = desc . _v_name <EOL> colPaths = [ join_paths ( descName , path ) for path in cols ] <EOL> colPaths . insert ( <NUM_LIT:0> , descName ) <EOL> parentCols = stack [ - <NUM_LIT:1> ] [ <NUM_LIT:1> ] <EOL> parentCols . extend ( colPaths ) <EOL> def _f_walk ( self , type = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> if type not in [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] : <EOL> raise ValueError ( """<STR_LIT>""" ) <EOL> stack = [ self ] <EOL> while stack : <EOL> object = stack . pop ( <NUM_LIT:0> ) <EOL> if type in [ "<STR_LIT>" , "<STR_LIT>" ] : <EOL> yield object <EOL> for name in object . _v_names : <EOL> new_object = object . _v_colobjects [ name ] <EOL> if isinstance ( new_object , Description ) : <EOL> stack . append ( new_object ) <EOL> else : <EOL> if type in [ "<STR_LIT>" , "<STR_LIT>" ] : <EOL> yield new_object <EOL> def __repr__ ( self ) : <EOL> """<STR_LIT>""" <EOL> rep = [ '<STR_LIT>' % <EOL> ( "<STR_LIT:U+0020>" * self . _v_nestedlvl , k , self . _v_colobjects [ k ] ) <EOL> for k in self . _v_names ] <EOL> return '<STR_LIT>' % ( '<STR_LIT>' . join ( rep ) ) <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT>' % self . _v_nested_descr <EOL> class MetaIsDescription ( type ) : <EOL> """<STR_LIT>""" <EOL> def __new__ ( cls , classname , bases , classdict ) : <EOL> """<STR_LIT>""" <EOL> newdict = { "<STR_LIT>" : { } , } <EOL> if '<STR_LIT>' in classdict : <EOL> newdict [ '<STR_LIT>' ] = classdict [ '<STR_LIT>' ] <EOL> for b in bases : <EOL> if "<STR_LIT>" in b . __dict__ : <EOL> newdict [ "<STR_LIT>" ] . update ( b . __dict__ [ "<STR_LIT>" ] ) <EOL> for k in classdict : <EOL> if not ( k . startswith ( '<STR_LIT>' ) ) : <EOL> newdict [ "<STR_LIT>" ] [ k ] = classdict [ k ] <EOL> return type . __new__ ( cls , classname , bases , newdict ) <EOL> class IsDescription ( six . with_metaclass ( MetaIsDescription , object ) ) : <EOL> """<STR_LIT>""" <EOL> def descr_from_dtype ( dtype_ ) : <EOL> """<STR_LIT>""" <EOL> fields = { } <EOL> fbyteorder = '<STR_LIT:|>' <EOL> for name in dtype_ . names : <EOL> dtype , pos = dtype_ . fields [ name ] [ : <NUM_LIT:2> ] <EOL> kind = dtype . base . kind <EOL> byteorder = dtype . base . byteorder <EOL> if byteorder in '<STR_LIT>' : <EOL> if fbyteorder not in [ '<STR_LIT:|>' , byteorder ] : <EOL> raise NotImplementedError ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> fbyteorder = byteorder <EOL> if kind in '<STR_LIT>' : <EOL> col = Col . from_dtype ( dtype , pos = pos ) <EOL> elif kind == '<STR_LIT>' and dtype . shape in [ ( ) , ( <NUM_LIT:1> , ) ] : <EOL> if dtype . shape != ( ) : <EOL> warnings . warn ( <EOL> "<STR_LIT>" ) <EOL> col , _ = descr_from_dtype ( dtype . base ) <EOL> col . _v_pos = pos <EOL> else : <EOL> raise NotImplementedError ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" % dtype ) <EOL> fields [ name ] = col <EOL> return Description ( fields ) , fbyteorder <EOL> def dtype_from_descr ( descr , byteorder = None ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( descr , dict ) : <EOL> descr = Description ( descr ) <EOL> elif ( type ( descr ) == type ( IsDescription ) <EOL> and issubclass ( descr , IsDescription ) ) : <EOL> descr = Description ( descr ( ) . columns ) <EOL> elif isinstance ( descr , IsDescription ) : <EOL> descr = Description ( descr . columns ) <EOL> elif not isinstance ( descr , Description ) : <EOL> raise ValueError ( '<STR_LIT>' % descr ) <EOL> dtype_ = descr . _v_dtype <EOL> if byteorder and byteorder != '<STR_LIT:|>' : <EOL> dtype_ = dtype_ . newbyteorder ( byteorder ) <EOL> return dtype_ <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> """<STR_LIT>""" <EOL> class Info ( IsDescription ) : <EOL> _v_pos = <NUM_LIT:2> <EOL> Name = UInt32Col ( ) <EOL> Value = Float64Col ( ) <EOL> class Test ( IsDescription ) : <EOL> """<STR_LIT>""" <EOL> x = Col . from_type ( "<STR_LIT>" , <NUM_LIT:2> , <NUM_LIT:0> , pos = <NUM_LIT:0> ) <EOL> y = Col . from_kind ( '<STR_LIT:float>' , dflt = <NUM_LIT:1> , shape = ( <NUM_LIT:2> , <NUM_LIT:3> ) ) <EOL> z = UInt8Col ( dflt = <NUM_LIT:1> ) <EOL> color = StringCol ( <NUM_LIT:2> , dflt = "<STR_LIT:U+0020>" ) <EOL> Info = Info ( ) <EOL> class info ( IsDescription ) : <EOL> _v_pos = <NUM_LIT:1> <EOL> name = UInt32Col ( ) <EOL> value = Float64Col ( pos = <NUM_LIT:0> ) <EOL> y2 = Col . from_kind ( '<STR_LIT:float>' , dflt = <NUM_LIT:1> , shape = ( <NUM_LIT:2> , <NUM_LIT:3> ) , pos = <NUM_LIT:1> ) <EOL> z2 = UInt8Col ( dflt = <NUM_LIT:1> ) <EOL> class info2 ( IsDescription ) : <EOL> y3 = Col . from_kind ( '<STR_LIT:float>' , dflt = <NUM_LIT:1> , shape = ( <NUM_LIT:2> , <NUM_LIT:3> ) ) <EOL> z3 = UInt8Col ( dflt = <NUM_LIT:1> ) <EOL> name = UInt32Col ( ) <EOL> value = Float64Col ( ) <EOL> class info3 ( IsDescription ) : <EOL> name = UInt32Col ( ) <EOL> value = Float64Col ( ) <EOL> y4 = Col . from_kind ( '<STR_LIT:float>' , dflt = <NUM_LIT:1> , shape = ( <NUM_LIT:2> , <NUM_LIT:3> ) ) <EOL> z4 = UInt8Col ( dflt = <NUM_LIT:1> ) <EOL> klass = Test ( ) <EOL> desc = Description ( klass . columns ) <EOL> print ( "<STR_LIT>" , desc ) <EOL> print ( "<STR_LIT>" , repr ( desc ) ) <EOL> print ( "<STR_LIT>" , desc . _v_names ) <EOL> print ( "<STR_LIT>" , desc . x ) <EOL> print ( "<STR_LIT>" , desc . Info ) <EOL> print ( "<STR_LIT>" , desc . Info . Value ) <EOL> print ( "<STR_LIT>" , desc . _v_nested_names ) <EOL> print ( "<STR_LIT>" , desc . _v_dflts ) <EOL> print ( "<STR_LIT>" , desc . _v_nested_formats ) <EOL> print ( "<STR_LIT>" , desc . _v_nested_descr ) <EOL> print ( "<STR_LIT>" , desc . info . _v_nested_descr ) <EOL> print ( "<STR_LIT>" , desc . _v_dtype . itemsize ) <EOL> for object in desc . _f_walk ( ) : <EOL> if isinstance ( object , Description ) : <EOL> print ( "<STR_LIT>" , end = '<STR_LIT:U+0020>' ) <EOL> print ( "<STR_LIT>" , object . _v_name ) <EOL> print ( "<STR_LIT>" , object . _v_dtype . itemsize ) <EOL> else : <EOL> print ( "<STR_LIT>" , object . _v_name , object . dtype ) <EOL> class testDescParent ( IsDescription ) : <EOL> c = Int32Col ( ) <EOL> class testDesc ( testDescParent ) : <EOL> pass <EOL> assert '<STR_LIT:c>' in testDesc . columns </s>
