Datasets:

h4iku
/

coconut_python2010_preprocessed

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 303k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
@unittest2.expectedFailure		def test_with_dsym(self): """Test 'image lookup -t days' and check for correct display.""" self.buildDsym() self.image_lookup_for_enum_type()
	for import_name, import_mod in mod.mv.imports.items(): var = defaultvar(import_name, None) var.imported = True getgx().types[inode(var)] = set([(import_mod, 0)]) self.imports[import_name] = import_mod	def visitFrom(self, node, parent=None): if not node in getmv().importnodes: # XXX use (func, node) as parent.. error("please place all imports (no 'try:' etc) at the top of the file", node) if hasattr(node, 'level') and node.level: error("relative imports are not supported", node)
label = Label(root)	label = Label(root, width=70, height=40)	def __init__(self, root, viewports): self.root = root self.viewports = viewports self.topButtonFrame = Frame(root) self.topButtonFrame.pack(side=TOP) self.botButtonFrame = Frame(root) self.botButtonFrame.pack(side=BOTTOM) self.button = Button(self.topButtonFrame, text="Quit", command=self.shutdown) self.button.pack(side=LEFT)
opts, args = getopt.getopt(sys.argv[1:], 'vbchef:wad:m:rl', ['extmod', 'nobounds', 'nowrap', 'flags=', 'dir=', 'makefile=', 'random', 'long', 'msvc'])	opts, args = getopt.getopt(sys.argv[1:], 'vbchef:wad:m:rl', ['help', 'extmod', 'nobounds', 'nowrap', 'flags=', 'dir=', 'makefile=', 'random', 'long', 'msvc', 'ann'])	def main(): setgx(newgx()) print '* SHED SKIN Python-to-C++ Compiler 0.6 ' print 'Copyright 2005-2010 Mark Dufour; License GNU GPL version 3 (See LICENSE)' print # --- some checks major, minor = sys.version_info[:2] if (major, minor) not in [(2, 4), (2, 5), (2, 6)]: print 'ERROR* Shed Skin is not compatible with this version of Python' sys.exit(1) if sys.platform == 'win32' and os.path.isdir('c:/mingw'): print 'ERROR please rename or remove c:/mingw, as it conflicts with Shed Skin' sys.exit() # --- command-line options try: opts, args = getopt.getopt(sys.argv[1:], 'vbchef:wad:m:rl', ['extmod', 'nobounds', 'nowrap', 'flags=', 'dir=', 'makefile=', 'random', 'long', 'msvc']) except getopt.GetoptError: usage() for o, a in opts: if o in ['-h', '--help']: usage() if o in ['-b', '--nobounds']: getgx().bounds_checking = False if o in ['-e', '--extmod']: getgx().extension_module = True if o in ['-a', '--ann']: getgx().annotation = True if o in ['-d', '--dir']: getgx().output_dir = a if o in ['-l', '--long']: getgx().longlong = True if o in ['-w', '--nowrap']: getgx().wrap_around_check = False if o in ['-r', '--random']: getgx().fast_random = True if o in ['-m', '--makefile']: getgx().makefile_name = a if o in ['-v', '--msvc']: getgx().msvc = True if o in ['-f', '--flags']: if not os.path.isfile(a): print "ERROR no such file: '%s'" % a sys.exit(1) getgx().flags = a # --- argument if len(args) != 1: usage() name = args[0] if not name.endswith('.py'): name += '.py' if not os.path.isfile(name): print "ERROR no such file: '%s'" % name sys.exit(1) getgx().main_mod = name[:-3] # --- analyze & annotate infer.analyze(name) annotate.annotate() cpp.generate_code()
self.timer = gobject.timeout_add(20, self.fire_timer)	self.timer = gobject.timeout_add(50, self.fire_timer)	def set_timer(self): self.timer = gobject.timeout_add(20, self.fire_timer)
if self.CPU_clock: gobject.source_remove(self.CPU_clock)	if self.timer: gobject.source_remove(self.timer)	def pause_CPU(self, widget, args, *kwargs): # FIXME abstract that properly. if self.CPU_clock: gobject.source_remove(self.CPU_clock) widget.set_label("_Continue") self.CPU_clock = None else: self.CPU_clock = gobject.timeout_add(10, C64.iterate) widget.set_label("_Pause")
self.CPU_clock = None	self.timer = None	def pause_CPU(self, widget, args, *kwargs): # FIXME abstract that properly. if self.CPU_clock: gobject.source_remove(self.CPU_clock) widget.set_label("_Continue") self.CPU_clock = None else: self.CPU_clock = gobject.timeout_add(10, C64.iterate) widget.set_label("_Pause")
self.CPU_clock = gobject.timeout_add(10, C64.iterate)	self.set_timer()	def pause_CPU(self, widget, args, *kwargs): # FIXME abstract that properly. if self.CPU_clock: gobject.source_remove(self.CPU_clock) widget.set_label("_Continue") self.CPU_clock = None else: self.CPU_clock = gobject.timeout_add(10, C64.iterate) widget.set_label("_Pause")
return lookupclass(cl.node.bases[0], getmv())	return cl.node.bases[0]	def supercall(self, node, parent): while isinstance(parent, function): parent = parent.parent if (isinstance(node.expr, CallFunc) and \ node.attrname not in ('__getattr__', '__setattr__') and \ isinstance(node.expr.node, Name) and \ node.expr.node.name == 'super'): if (len(node.expr.args) >= 2 and \ isinstance(node.expr.args[1], Name) and node.expr.args[1].name=='self'): cl = lookupclass(node.expr.args[0], getmv()) if cl.node.bases: return lookupclass(cl.node.bases[0], getmv()) error("unsupported usage of 'super'", node)
supercall = self.supercall(node.node, func) if supercall: node.node = Getattr(Name(supercall.ident), node.node.attrname)	base = self.supercall(node.node, func) if base: node.node = Getattr(copy.deepcopy(base), node.node.attrname)	def visitCallFunc(self, node, func=None): # XXX clean up!! newnode = cnode(node, parent=func)
propagate(10)	propagate(0)	def lookahead(): # mods: [list(int)] global lit_mask lit_mask = [1]
def supercall(self, node, parent):	def supercall(self, orig, parent): node = orig.node	def supercall(self, node, parent): while isinstance(parent, function): parent = parent.parent if (isinstance(node.expr, CallFunc) and \ node.attrname not in ('__getattr__', '__setattr__') and \ isinstance(node.expr.node, Name) and \ node.expr.node.name == 'super'): if (len(node.expr.args) >= 2 and \ isinstance(node.expr.args[1], Name) and node.expr.args[1].name=='self'): cl = lookupclass(node.expr.args[0], getmv()) if cl.node.bases: return cl.node.bases[0] error("unsupported usage of 'super'", node)
error("unsupported usage of 'super'", node)	error("unsupported usage of 'super'", orig)	def supercall(self, node, parent): while isinstance(parent, function): parent = parent.parent if (isinstance(node.expr, CallFunc) and \ node.attrname not in ('__getattr__', '__setattr__') and \ isinstance(node.expr.node, Name) and \ node.expr.node.name == 'super'): if (len(node.expr.args) >= 2 and \ isinstance(node.expr.args[1], Name) and node.expr.args[1].name=='self'): cl = lookupclass(node.expr.args[0], getmv()) if cl.node.bases: return cl.node.bases[0] error("unsupported usage of 'super'", node)
base = self.supercall(node.node, func)	base = self.supercall(node, func)	def visitCallFunc(self, node, func=None): # XXX clean up!! newnode = cnode(node, parent=func)
food_type_file.write(str(float(univ.total_food)/float(univ.total_wrong_food))+ '\n')	univ.food_type_file.write(str(float(univ.total_food)/float(univ.total_wrong_food))+ '\n')	def record(univ): ctime = univ.ttime points_file=open(univ.folder_name+'/points'+(str(ctime/1000000)),'w') points_file.write('points: '+ str(univ.points) +' rewarded: ' + str(univ.reward)) connex_final_file=open(univ.folder_name+'/connex'+(str(ctime/1000000)),'w') food_file=open(univ.folder_name+'/burger_time','w') out_spike_file=open(univ.folder_name+'/out_spike','w') if univ.total_wrong_food > 0: food_type_file.write(str(float(univ.total_food)/float(univ.total_wrong_food))+ '\n') connex_final_file.write(str(univ.lmax)+'\n') for layer_size in univ.layer_sizes: connex_final_file.write(str(layer_size[0]) +' ' + str(layer_size[1]) + ' '+ str(layer_size[2]) + '\n') for syn_sum in univ.synsumco: connex_final_file.write(str(syn_sum) + ' ' ) connex_final_file.write('\n') for layer in univ.spirit_brain.cell_array: for row in layer: for item in row: for cell in item: for connection in cell.connections: other_cell = connection.post_cell connex_final_file.write( str(cell.cell_type) + ' ' + str(cell.layer) + ' ' + str(cell.x) + ' ' + str(cell.y) + ' ' + str(other_cell.cell_type) + ' ' +str(other_cell.layer) + ' ' + str(other_cell.x) + ' ' + str(other_cell.y) + ' ' + str(connection.s) + ' ' + str(int(connection.fast))+ ' ' + str(int(connection.plastic)) +'\n') univ.food_times.append(ctime) for food_time in univ.food_times: food_file.write(str(food_time) +'\n') univ.out_spikes.append(ctime) for out_spike in univ.out_spikes: out_spike_file.write(str(out_spike) +'\n') points_file.close() connex_final_file.close() food_file.close() out_spike_file.close()
blah = Blah(7, 'eight') woef(1)	class do: def __init__(self, public, do): self.public = public self.do = do if __name__ == '__main__': blah = Blah(7, 'eight') woef(1) d = do('public', 'do')	def woef(x): print x
d = (1, (1.1, 'u')) a, (b, c) = d e, f = d for x,(y,z) in [d]: x y z l = [((v,u),w) for u,(v,w) in [d]] print 'u', l	d = (1, (1.1, 'u')) a, (b, c) = d e, f = d for x,(y,z) in [d]: x y z l = [((v,u),w) for u,(v,w) in [d]] print 'uh', '%.2f %d' % l[0][0], l[0][1], len(l)	def _sum(l): # l: [pyiter(A)] first = True # [int] for e in l: # [pyiter(A)] if first: # [] result = e # [A] first = False # [int] else: result += e # [A] return result # [A]
if cl.module not in [getmv().module, getgx().modules['builtin']] and not (cl.ident in getmv().ext_funcs or cl.ident in getmv().ext_classes): if cplusplus: namespace = cl.module.full_path()+'::' else: namespace = '::'.join(cl.module.mod_path)+'::'	if cl.module not in [getmv().module, getgx().modules['builtin']]: if not (cl.ident in getmv().ext_funcs or cl.ident in getmv().ext_classes): if cplusplus: namespace = cl.module.full_path()+'::' else: namespace = '::'.join(cl.module.mod_path)+'::'	def map(ident): if cplusplus: return ident+' *' return conv.get(ident, ident)
print >>gv.out, ' __%s__::%s *__ss_object;' % (cl.module.ident, cl.ident)	print >>gv.out, ' __%s__::%s *__ss_object;' % (cl.module.ident, cpp.nokeywords(cl.ident))	print >>gv.out, 'typedef struct {'
print >>gv.out, ' self->__ss_object = new __%s__::%s();' % (cl.module.ident, cl.ident)	print >>gv.out, ' self->__ss_object = new __%s__::%s();' % (cl.module.ident, cpp.nokeywords(cl.ident))	print >>gv.out, 'typedef struct {'
print >>gv.out, 'PyObject *%s::__to_py__() {' % cl.cpp_name	print >>gv.out, 'PyObject *%s::__to_py__() {' % cpp.nokeywords(cl.ident)	def convert_methods(gv, cl, declare): if declare: print >>gv.out, ' PyObject __to_py__();' else: print >>gv.out, 'namespace __%s__ { / XXX /\n' % cl.module.ident print >>gv.out, 'PyObject %s::__to_py__() {' % cl.cpp_name print >>gv.out, ' if(__ss_proxy->has_key(this))' print >>gv.out, ' return (PyObject )(__ss_proxy->__getitem__(this));' print >>gv.out, ' %sObject self = (%sObject )(%sObjectType.tp_alloc(&%sObjectType, 0));' % (4(cl.ident,)) print >>gv.out, ' self->__ss_object = this;' print >>gv.out, ' __ss_proxy->__setitem__(self->__ss_object, self);' print >>gv.out, ' return (PyObject )self;' print >>gv.out, '}\n}\n' print >>gv.out, 'namespace __shedskin__ { / XXX /\n' print >>gv.out, 'template<> __%s__::%s __to_ss(PyObject p) {' % (cl.module.ident, cl.cpp_name) print >>gv.out, ' if(p == Py_None) return NULL;' print >>gv.out, ' if(PyObject_IsInstance(p, (PyObject )&__%s__::%sObjectType)!=1)' % (cl.module.ident, cl.ident) print >>gv.out, ' throw new TypeError(new str("error in conversion to Shed Skin (%s expected)"));' % cl.ident print >>gv.out, ' return ((__%s__::%sObject *)p)->__ss_object;' % (cl.module.ident, cl.ident) print >>gv.out, '}\n}'
print >>gv.out, 'template<> __%s__::%s __to_ss(PyObject p) {' % (cl.module.ident, cl.cpp_name)	print >>gv.out, 'template<> __%s__::%s __to_ss(PyObject p) {' % (cl.module.ident, cpp.nokeywords(cl.ident))	def convert_methods(gv, cl, declare): if declare: print >>gv.out, ' PyObject __to_py__();' else: print >>gv.out, 'namespace __%s__ { / XXX /\n' % cl.module.ident print >>gv.out, 'PyObject %s::__to_py__() {' % cl.cpp_name print >>gv.out, ' if(__ss_proxy->has_key(this))' print >>gv.out, ' return (PyObject )(__ss_proxy->__getitem__(this));' print >>gv.out, ' %sObject self = (%sObject )(%sObjectType.tp_alloc(&%sObjectType, 0));' % (4(cl.ident,)) print >>gv.out, ' self->__ss_object = this;' print >>gv.out, ' __ss_proxy->__setitem__(self->__ss_object, self);' print >>gv.out, ' return (PyObject )self;' print >>gv.out, '}\n}\n' print >>gv.out, 'namespace __shedskin__ { / XXX /\n' print >>gv.out, 'template<> __%s__::%s __to_ss(PyObject p) {' % (cl.module.ident, cl.cpp_name) print >>gv.out, ' if(p == Py_None) return NULL;' print >>gv.out, ' if(PyObject_IsInstance(p, (PyObject )&__%s__::%sObjectType)!=1)' % (cl.module.ident, cl.ident) print >>gv.out, ' throw new TypeError(new str("error in conversion to Shed Skin (%s expected)"));' % cl.ident print >>gv.out, ' return ((__%s__::%sObject *)p)->__ss_object;' % (cl.module.ident, cl.ident) print >>gv.out, '}\n}'
print >>gv.out, 'static PyTypeObject %sObjectType = {' % cl.ident	print >>gv.out, 'PyTypeObject %sObjectType = {' % cl.ident	print >>gv.out, 'typedef struct {'
version='alpha-0.171',	version='alpha-0.172',	def fullsplit(path, result=None): """ Split a pathname into components (the opposite of os.path.join) in a platform-neutral way. """ if result is None: result = [] head, tail = os.path.split(path) if head == '': return [tail] + result if head == path: return result return fullsplit(head, [tail] + result)
self.widget = AjaxForeignKeyWidget(attrs={'type': key_type, 'width': 35, 'ajax_func': ajax_func, 'shadow_field': shadow_field_name})	self.widget = AjaxForeignKeyWidget(attrs={'type': key_type, 'width': 35, 'ajax_func': ajax_func, 'shadow_field': shadow_field_name, 'field_name': field_name})	def __init__(self, field_name='', field=None, key_type=None, to_field=None, to_field_name=None, required=True, label='', localize=False, initial=None, widget=None, help_text='', ajax_func=None, queryset=None, error_messages=None, show_hidden_initial=False, shadow_field_name=None, args, *kwargs):
context['program'] = self.program	context['program'] = prog	def get_student_schedules(request, students, prog, extra='', onsite=False): """ generate student schedules """
	basedir = 'program/modules/programprintables/'	def get_student_schedules(request, students, prog, extra='', onsite=False): """ generate student schedules """
return render_to_response(self.baseDir()+'studentschedule.html', request, (prog, tl), context)	return render_to_response(basedir+'studentschedule.html', request, (prog, tl), context)	def get_student_schedules(request, students, prog, extra='', onsite=False): """ generate student schedules """
schedule_template = select_template([self.baseDir()+'program_custom_schedules/%s_studentschedule.tex' %(self.program.id), self.baseDir()+'studentschedule.tex'])	schedule_template = select_template([basedir+'program_custom_schedules/%s_studentschedule.tex' %(prog.id), basedir+'studentschedule.tex'])	def get_student_schedules(request, students, prog, extra='', onsite=False): """ generate student schedules """
@register.filter def makelist(lst): if len(lst) == 0: return 'No responses' result = '' for item in lst: result += '<li>' + str(item) + '</li>' + '\n' return result		def drop_empty_answers(lst): # Takes a list of answers and drops empty ones. Whitespace-only is empty. return [ ans for ans in lst if (not isinstance(ans.answer, basestring)) or ans.answer.strip() ]
def list_classes(ans): if not isinstance(ans, list): return ans newlist = [] for key in ans: try: intkey = int(key) except ValueError: return '<ul>\n' + makelist( ans ) + '</ul>\n' q = ClassSubject.objects.filter(id=intkey) if q.count() == 1: newlist.extend( [ c.emailcode() + ': ' + c.title() for c in q ] ) else: newlist.append( key ) return '<ul>\n' + makelist( newlist ) + '</ul>\n'	def answer_to_list(ans): if isinstance(ans.answer, list): value = ans.answer else: value = [ ans.answer ] if ans.question.question_type.name == 'Favorite Class': return [ c.emailcode() + ': ' + c.title() for c in ClassSubject.objects.filter(id__in=value) ] return value	def list_classes(ans): # If the answer is a list of classes, render a shiny list of their titles. # If the answer is an ordinary list, prettify the list. # Otherwise just spit the answer back out. # Kind of inelegant, but I didn't want to make yet another set of templates. if not isinstance(ans, list): return ans newlist = [] for key in ans: try: intkey = int(key) except ValueError: return '<ul>\n' + makelist( ans ) + '</ul>\n' # If we get a non-integer answer, quit early. q = ClassSubject.objects.filter(id=intkey) if q.count() == 1: newlist.extend( [ c.emailcode() + ': ' + c.title() for c in q ] ) else: newlist.append( key ) # If no class matches, spit out the raw answer. return '<ul>\n' + makelist( newlist ) + '</ul>\n'
if Tag.getTag('ask_about_duplicate_accounts', default='False') == 'True':	if Tag.getTag('require_email_validation', default='False') == 'True':	def user_registration(request): """ Registration view -- takes care of users who want to create a new account. """ if request.user.is_authenticated(): return render_to_response('registration/already_logged_in.html', request, request.get_node('Q/Web/myesp'), {}) if request.method == 'POST': form = UserRegForm(request.POST) if form.is_valid(): ## First, check to see if we have any users with the same e-mail if not 'do_reg_no_really' in request.POST and Tag.getTag('ask_about_duplicate_accounts', default='False') == 'True': existing_accounts = User.objects.filter(email=form.cleaned_data['email'], is_active=True).exclude(password='emailuser') if len(existing_accounts) != 0: return render_to_response('registration/newuser.html', request, request.get_node('Q/Web/myesp'), { 'accounts': existing_accounts, 'form': form, 'site': Site.objects.get_current() }) try: user = User.objects.get(email=form.cleaned_data['email'], password = 'emailuser') except User.DoesNotExist: try: user = User.objects.filter(username = form.cleaned_data['username'], is_active = False).latest('date_joined') except User.DoesNotExist: user = User(email = form.cleaned_data['email']) user.username = form.cleaned_data['username'] user.last_name = form.cleaned_data['last_name'] user.first_name = form.cleaned_data['first_name'] user.set_password(form.cleaned_data['password']) # Append key to password and disable until activation if desired if Tag.getTag('ask_about_duplicate_accounts', default='False') == 'True': userkey = random.randint(0,2**31 - 1) user.password += "_%d" % userkey user.is_active = False user.save() ESPUser_Profile.objects.get_or_create(user = user) role_verb = GetNode('V/Flags/UserRole/%s' % form.cleaned_data['initial_role']) role_bit = UserBit.objects.create(user = user, verb = role_verb, qsc = request.get_node('Q'), recursive = False) if Tag.getTag('require_email_validation', default='False') == 'False': user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password']) login(request, user) return HttpResponseRedirect('/myesp/profile/') else: from django.template import Context as RawContext t = loader.get_template('registration/activation_email.txt') c = RawContext({'user': user, 'activation_key': userkey, 'site': Site.objects.get_current()}) send_mail("Account Activation", t.render(c), settings.SERVER_EMAIL, [user.email], fail_silently = False) return render_to_response('registration/account_created_activation_required.html', request, request.get_node('Q/Web/myesp'), {'user': user, 'site': Site.objects.get_current()}) else: form = UserRegForm() return render_to_response('registration/newuser.html', request, request.get_node('Q/Web/myesp'),{'form':form})
prog = module.program	prog = module.get_program()	def hide_choice_if_useless(field): """ Hide a choice field if there's only one choice """ if len(field.choices) == 1: hide_field(field, default=field.choices[0][0])
unavailable_teachers = User.objects.filter(id__in=list(teacher_dict['class_approved'])+list(teacher_dict['class_proposed'])).exclude(id__in=teacher_dict['availability']).distinct()	unavailable_teachers = User.objects.filter(id__in=list(teacher_dict['class_approved'].values_list('id', flat=True))+list(teacher_dict['class_proposed'].values_list('id', flat=True))).exclude(id__in=teacher_dict['availability']).distinct()	def force_availability(self, request, tl, one, two, module, extra, prog): teacher_dict = prog.teachers() if request.method == 'POST': if request.POST.has_key('sure') and request.POST['sure'] == 'True': # Find all teachers who have not indicated their availability and do it for them. unavailable_teachers = User.objects.filter(id__in=list(teacher_dict['class_approved'])+list(teacher_dict['class_proposed'])).exclude(id__in=teacher_dict['availability']).distinct() for t in unavailable_teachers: teacher = ESPUser(t) for ts in prog.getTimeSlots(): teacher.addAvailableTime(self.program, ts) return self.scheduling(request, tl, one, two, module, 'refresh', prog) else: return self.scheduling(request, tl, one, two, module, '', prog) # Normally, though, return a page explaining the issue. context = {'prog': self.program} context['good_teacher_num'] = User.objects.filter(id__in=teacher_dict['class_approved']).filter(id__in=teacher_dict['availability']).distinct().count() context['total_teacher_num'] = User.objects.filter(id__in=teacher_dict['class_approved']).distinct().count()
break if not module: raise Http404	return ProgramModuleObj.getFromProgModule(prog, module)	def findModuleObject(tl, call_txt, prog): modules = ProgramModule.objects.filter(main_call = call_txt, module_type = tl).select_related()[:1]
if not module: raise Http404 return ProgramModuleObj.getFromProgModule(prog, module)	return ProgramModuleObj.getFromProgModule(prog, module) raise Http404	def findModuleObject(tl, call_txt, prog): modules = ProgramModule.objects.filter(main_call = call_txt, module_type = tl).select_related()[:1]
if tl != "manage" and request.user.is_authenticated() and isinstance(moduleobj, CoreModule): other_modules = moduleobj.findCategoryModules(False) for m in other_modules: m.request = request m.user = user if not m.isCompleted() and hasattr(m, m.module.main_call): return getattr(m, m.module.main_call)(request, tl, one, two, call_txt, extra, prog)		def findModule(request, tl, one, two, call_txt, extra, prog): moduleobj = ProgramModuleObj.findModuleObject(tl, call_txt, prog) user = ESPUser(request.user) # If a "core" module has been found: # Put the user through a sequence of all required modules in the same category. if tl != "manage" and request.user.is_authenticated() and isinstance(moduleobj, CoreModule): other_modules = moduleobj.findCategoryModules(False) for m in other_modules: m.request = request m.user = user if not m.isCompleted() and hasattr(m, m.module.main_call): return getattr(m, m.module.main_call)(request, tl, one, two, call_txt, extra, prog)
sqlcontent = str(sqlcontent)	sqlcontent = unicodedata.normalize('NFKD', unicode(sqlcontent)).encode('ascii', 'ignore')	def process_response(self, request, response):
qs = self.registrations.filter(id=user.id, studentregistration__start_date__lte=now, studentregistration__end_date__gte=now)	rt = RegistrationType.get_cached(name=prereg_verb, category='student') qs = self.registrations.filter(id=user.id, studentregistration__start_date__lte=now, studentregistration__end_date__gte=now, studentregistration__relationship=rt)	def preregister_student(self, user, overridefull=False, priority=1, prereg_verb = None, fast_force_create=False): StudentRegistration, RegistrationType = self.StudentRegistration, self.RegistrationType
rt = RegistrationType.get_cached(name=prereg_verb, category='student')		def preregister_student(self, user, overridefull=False, priority=1, prereg_verb = None, fast_force_create=False): StudentRegistration, RegistrationType = self.StudentRegistration, self.RegistrationType