def selectReading(): if not Session.getSession('signedin'): return redirect(url_for('signin')) flash(dbPath) form = SelectReadingForm(request.form) jinjadict.update(dict(form=form)) with db_session: heldReadings = Readings.select( lambda c: c.am is not None and c.pm is None).order_by(1) heldReadingsList = list(heldReadings) numberOfHeldReadings = len(heldReadingsList) if numberOfHeldReadings > 0: heldReadingDates = [] index = 1 for heldReading in heldReadingsList: heldReadingDates.append((f'D{index}', heldReading.date)) index += 1 form.helddateslist.choices = heldReadingDates Session.putSession('heldDates', heldReadingDates) return render_template('SelectReading.jinja2', **jinjadict) # form=heldForm) else: return render_template('NoneHeld.jinja2', **jinjadict)
def __init__(self): super(TermWidgetImpl, self).__init__() m_terminalDisplay = TerminalDisplay() m_session = Session() m_session.createSession() m_terminalDisplay.createTerminalDisplay(m_session, self)
def signin(): # f = open('/home/bill/glucose2-dev/glucose2-dev/wdt.log', 'w') # f.write(f'signin() {request.method}') # f.close() log('signin', f'{request.method}') if request.method == 'GET': flash(dbPath) form = SigninForm(request.form) jinjadict.update(dict(form=form)) log('signin', 'render_template(Signin.jinja2)') return render_template('Signin.jinja2', **jinjadict) else: form = SigninForm(request.form) jinjadict.update(dict(form=form)) typedcode = form.data['code'] log('signin', f'typedcode = {typedcode}') savedcode = System.getCode() log('signin', f'savedcode = {savedcode}') signedin = verify_password(savedcode, typedcode) Session.putSession('signedin', signedin) if signedin: # with db_session: # numberOfHeldReadings = len(Readings.select(lambda c: (c.am is not None and c.pm is not None) or c.hold is not None)) # log(f'signin: numberOfHeldReadings = {numberOfHeldReadings}') # jinjadict.update(dict(numberOfHeldReadings=numberOfHeldReadings)) rv = redirect(url_for('admin')) log('signin', 'redirect(url_for("admin"))') return rv else: flash('Try Again') return redirect(url_for('signin'))
def run(self): totalScore = 0.0 for grid in MultipleSessions.grids: session = Session(self.robby, copy.deepcopy(grid)) score = session.run() self.robby.clean() totalScore = totalScore + score return ( totalScore / len(MultipleSessions.grids) )
def run(self): total_score = 0.0 for grid in MultipleSessions.grids: session = Session(self.robby, copy.deepcopy(grid)) score = session.run() self.robby.clean() total_score = total_score + score return total_score / len(MultipleSessions.grids)
def home(): global firstTimeThrough if firstTimeThrough: Session.initSession() firstTimeThrough = False log('home', '*********************** starting **********************') log('home', request.method) Session.putSession('signedin', False) return render_template('Home.jinja2', title='Glucose Chart')
def __init__(self, starting_id=None, pal=None, recursivity_level=1, *args, **kwargs): super(Scrapper, self).__init__(*args, **kwargs) #Thread.__init__(self) self.kill_yourself = False self.starting_id = starting_id self.pal = pal self.session = Session() self.browser = webdriver.Firefox()
def create(self, data: T.Union[T.Dict[str, T.Any], BaseModel]) -> DbBaseModel: json_data: T.Dict[str, T.Any] if isinstance(data, BaseModel): json_data = jsonable_encoder(data) else: json_data = data obj = self.model(**json_data) Session.add(obj) Session.commit() return obj
def OnLogin(self, event): global PASSWORD PASSWORD = self.password.GetValue() # Valid Check if self.username.GetValue() == '' or self.password.GetValue() == '': Util.MessageBox(self, u'缺少用户名或密码!', u'错误', wx.OK | wx.ICON_ERROR) return dlg = ProgressDialog.ProgressDialog(self, u'连接服务器...') url = 'http://%s:5000/v2.0' % (Setting.getServer()) RestartDeviceRequests() loginthread = LoginThread(dlg, url, self.username.GetValue(), self.password.GetValue()) loginthread.start() #ret = dlg.ShowModal() #dlg.Destroy() if dlg.ShowModal() == wx.ID_CANCEL: loginthread.stop() return if loginthread: loginthread.stop() dlg.Destroy() Logger.info("Connect to %s", url) Logger.info("UserId: %s, Password: ******", self.username.GetValue()) ret, reason, detail = loginthread.getReturnValue() Logger.info("Result: %s, reason: %s, detail: %s", ret, reason, detail) if Setting.getSign().lower() == 'false': self.password.SetValue('') self.password.SetFocus() if not ret: Util.MessageBox(self, detail, reason, wx.OK | wx.ICON_ERROR) Session.logout() else: Setting.setLastLogin(FirstUser['firstuser'].username) if self.sign.GetValue() == True: Setting.setPasswd(self.password.GetValue()) else: Setting.setPasswd('1df#$!cd123~') Setting.save() area = wx.Display().GetGeometry() width = area.GetWidth() height = area.GetHeight() f = MainFrame.MainFrame(self.GetParent(), (width, height)) f.ShowFullScreen(True) self.GetParent().Hide()
def update(obj: DbBaseModel, data: T.Union[T.Dict[str, T.Any], BaseModel]) -> DbBaseModel: json_data: T.Dict[str, T.Any] if isinstance(data, BaseModel): json_data = jsonable_encoder(data) else: json_data = data for attribute, value in json_data.items(): if hasattr(obj, attribute): setattr(obj, attribute, value) Session.commit() return obj
def StartClassification(self, ArrayToClassify): result = 0.0 shortest_path = "" # looping on every stroke in dataset and add in array for classification for i in TrainingFilePath: file = i.split() dataset_wave = [] f = open(str(file), "r") # adding every frame data in arr2 then add all frames in dataset_wave for x in f: line = x.split() arr2 = [] for l in range(15): arr2.append(float(line[i])) dataset_wave.append(arr2) dataset_wavee = np.array(dataset_wave) app_wavee = np.array(ArrayToClassify) distance = 0.0 distance, path = fastdtw(dataset_wavee, app_wavee, dist=euclidean) if (result == 0.0): result = distance shortest_path = file elif (result > distance): result = distance shortest_path = file string = shortest_path.split('/') isMistake = False StrokeType = "" ErrorType = "" if (string[1] == "Wrong"): self.noWrong += 1 isMistake = True ErrorType = string[3] else: self.noCorrect += 1 StrokeType = string[2] Session.GetSessionInfo(ArrayToClassify) Session.InsertClassificationResult(ErrorType, isMistake, StrokeType)
def validator(*args, **kwargs): sess = Session(session, get_database()) Logger.dbg("validator: Request headers:\n=====\n{}\n=====\n".format( request.headers)) if not sess.validate_session(): Logger.fail('@authorized: User not authenticated.') return jsonify({ 'status': 401, 'message': 'Unauthorized. Please login first.' }) else: Logger.ok('@authorized: User authenticated.') return f(*args, **kwargs)
def setupNumberOfPartials(): with db_session: numberOfHeldReadings = len( Readings.select(lambda c: c.am is not None and c.pm is None)) Session.putSession('numberOfHeldReadings', numberOfHeldReadings) log('setUpNumberOfPartials', f'numberOfHeldReadings = {numberOfHeldReadings}') if numberOfHeldReadings == 0: flash('There are no partial readings.') elif numberOfHeldReadings == 1: flash('There is one partial reading.') else: flash(f'There are {numberOfHeldReadings} partial readings.') jinjadict.update(dict(numberOfHeldReadings=numberOfHeldReadings))
def run_single(self, sample, iterations, threshold): if (not self.haskey) and self.evaluate: self.generate_key() if self.haskey: self.load_key() print("...Finding fds ...") session = Session(self.ID, self.inputName, self.inputData, self.field, self.write_loc, mode="normal") session.config(sample[0], iterations[0], threshold[0], self.silent, self.evaluate, self.key)
def generate_key(self): print("...Genertating key ...") session = Session(self.ID, self.evName, self.evData, self.evField, self.write_loc, mode="key") self.key = session.config_test() # save the key keyName = self.read_loc + "key-{}.json".format( self.inputName.split(".")[0]) keyfile = open(keyName, "w+") keyfile.write(json.dumps(self.key)) print(self.key)
def loginWithAuthToken(self, authToken=None, appName=None): if authToken == None: raise Exception("Please set authToken") if appName == None: appName = self.APP_NAME self.Headers["X-Line-Application"] = appName self.Headers["X-Line-access"] = authToken self.authToken = authToken self.talk = Session(self.LINE_HOST_DOMAIN, self.Headers, self.LINE_API_QUERY_PATH_FIR).Talk() self.poll = Session(self.LINE_HOST_DOMAIN, self.Headers, self.LINE_POLL_QUERY_PATH_FIR).Talk() #self.call=Sesion(self.LINE_HOST_DOMAIN,self.Headers,self.LINE_CALL_QUERY_PATH).Call() #self.channel=Session(self.LINE_HOST_DOMAIN,self.Headers,self.LINE_CHAN_QUERY_PATH).Channel() #self.square=Session(self.LINE_HOST_DOMAIN,self.Headers,self.LINE_SQUARE_QUERY_PATH).Square() #self.shop=Session(self.LINE_HOST_DOMAIN,self.Headers,self.LINE_SHOP_QUERY_PATH).Shop() self.isLogin = True
def autoLogin(self): if Setting.getSign().lower() == 'false': return False if Setting.getAuto().lower() == 'true': pass else: return False username = Setting.getLastLogin() passwd = Setting.getPasswd() if username == '' or passwd == '': Util.MessageBox(self, u'缺少用户名或密码!', u'错误', wx.OK | wx.ICON_ERROR) return dlg = ProgressDialog.ProgressDialog(self, u'连接服务器...') dlg.CenterOnScreen() url = 'http://%s:5000/v2.0' % (Setting.getServer()) RestartDeviceRequests() loginthread = LoginThread(dlg, url, username, passwd) loginthread.start() #dlg.SetPosition((100,100)) #dlg.Move((Resource.screenX-dlg.)) #dlg.CenterOnScreen() #ret = dlg.ShowModal() #dlg.Destroy() if dlg.ShowModal() == wx.ID_CANCEL: loginthread.stop() return if loginthread: loginthread.stop() dlg.Destroy() Logger.info("Connect to %s", url) Logger.info("UserId: %s, Password: ******", username) ret, reason, detail = loginthread.getReturnValue() Logger.info("Result: %s, reason: %s, detail: %s", ret, reason, detail) if not ret: Util.MessageBox(self, detail, reason, wx.OK | wx.ICON_ERROR) self.ShowFullScreen(True) Session.logout() else: f = MainFrame.MainFrame(self.GetParent(), wx.ScreenDC().GetSize()) f.ShowFullScreen(True) self.GetParent().Hide()
def initUi(self): """Ui Setup.""" start = Session.MultiSession(self) layout = QVBoxLayout() layout.addWidget(start) self.setLayout(layout)
def __init__(self, application, request, **kwargs): super(BaseHandler, self).__init__(application, request, **kwargs) LOG.info('web request init') if self.use_session: self.session = Session.Session(self) self.session.load()
def getSession(self,sessionKey) : if self.repository.existsByKeyAndCommit(sessionKey,Session) : self.printWarning(f'"{sessionKey}" session key already exists') return self.repository.findByKeyAndCommit(sessionKey,Session) else : newSession = Session(sessionKey,FrameworkStatus[FrameworkConstant.INACTIVE],[]) return self.repository.saveAndCommit(newSession)
def run(self): while not self.cancel: if self.refresh > 0: self.lock.acquire() self.refreshVM() self.lock.release() self.refresh = self.refresh - 1 else: if self.tenRefresh == 0: # Del by wangderan 20150525 start #Session.logout() # Del by wangderan 20150525 end url = 'http://%s%s' % (Setting.getServer(), ":5000/v2.0") _auth_url = url username = Setting.getLastLogin() _user = username _password = LoginFrame.PassWord() ret, reason, detail = Session.login( _auth_url, _user, _password) Logger.info("ReLogin Status: Result: %s", ret) self.lock.acquire() self.refreshVM() self.lock.release() self.tenRefresh = 900 else: self.tenRefresh = self.tenRefresh - 1 wx.Sleep(2)
def save(self): """ Helper method to save changes to a certain object. """ session = Session.object_session(self) session.add(self) session.commit()
def delete(self): """ Helper method to delete a certain object. """ session = Session.object_session(self) session.delete(self) session.commit()
def main(uri): session = Session.Http(uri) ## Uncomment for extra debug info #session.print_status = True #session.print_data = True session.auth_user_callback() # Config Tree Flows... flows_config_tree = ConfigTree.flowsHttpAccess(session) print("There are {0} flows in the config tree".format( len(flows_config_tree.read_collection()))) for idx, flow_config_tree in enumerate(flows_config_tree.read_collection()): if idx > 0: print("\n") print("Config Tree flow {0}\n{1}".format(idx, flow_config_tree.to_json())) print('='*50) flows_op_tree = OperationalTree.flowStatsHttpAccess(session) print("There are {0} flows in the operational tree".format( len(flows_op_tree.read_collection()))) for idx, flow_op_tree in enumerate(flows_op_tree.read_collection()): if idx > 0: print("\n") print("Operational Tree flow {0}\n{1}".format(idx, flow_op_tree.to_json()))
def get_session(self): '''get this scans information, return a Session object''' run_node = self.__dom.getElementsByTagName('nmaprun')[0] hosts_node = self.__dom.getElementsByTagName('hosts')[0] finish_time = self.__dom.getElementsByTagName( 'finished')[0].getAttribute('timestr') nmap_version = run_node.getAttribute('version') start_time = run_node.getAttribute('startstr') scan_args = run_node.getAttribute('args') total_hosts = hosts_node.getAttribute('total') up_hosts = hosts_node.getAttribute('up') down_hosts = hosts_node.getAttribute('down') MySession = { 'finish_time': finish_time, 'nmap_version': nmap_version, 'scan_args': scan_args, 'start_time': start_time, 'total_hosts': total_hosts, 'up_hosts': up_hosts, 'down_hosts': down_hosts } self.__session = Session.Session(MySession) return self.__session
def clientSocket(self): bytes, address = self.client.recvfrom(65535) if bytes != 0: key = address[0] + ":" + str(address[1]) if key not in self.sessions: print(key + "からデータが送られてきました") self.sessions[key] = Session.Session(self.popyip, self.serverip, self.serverport) self.sessions[key].send(bytes)
def run(self): if self.cancel: return #wx.CallAfter(self.window.WorkFinished, u'下载根证书... 成功') wx.CallAfter(self.window.Update, 1, u'正在连接服务器 ...') self.ret = Session.login(self.url, self.username, self.password) wx.CallAfter(self.window.WorkFinished, u'认证成功') wx.CallAfter(self.window.Finish)
def createSession(self, aArrayPtrSourceNodesOfTopology): method = "createSession" id = self.IDispatch.GetIDsOfNames(method, **self.currentlcid) aIID = '{742AC001-D1E0-40A8-8EFE-BA1A550F8805}' arg = [] arg.append(aArrayPtrSourceNodesOfTopology) arg.append(aIID) return Session.Session(self.IDispatch.Invoke(id[0], *arg))
def backup(local_dir): session = Session.Session() drive_service = session.getService() files = Util.retrieve_all_files(drive_service) root_dir = Util.get_root_id(files) backup_service = DriveBackup.DriveBackup(root_dir) backup_service.createBackup(drive_service, local_dir)
def run_batch(self, sample, iterations, threshold): if (not self.haskey) and self.evaluate: self.generate_key() if self.haskey: self.load_key() print("...Finding fds ...") for s in sample: for i in iterations: for t in threshold: session = Session(self.ID, self.inputName, self.inputData, self.field, self.write_loc, mode="normal") session.config(s, i, t, self.silent, self.evaluate, self.key)
def updateUserAdEntry(obj, entry): session = Session.Session() session.click = int(entry[0]) session.depth = int(entry[5]) session.impression = int(entry[1]) session.position = int(entry[6]) session.queryId = int(entry[7]) obj.sessionList.append(session)
def process_file(self, root, file_node): Session.begin(self.header_jar) self._set_current_file(root, file_node) # Do not add unneeded header files modified = self.modified self.modified = False self._process_free_functions() self._process_global_constants() self._process_enums() if self.modified: self.header_jar.add_headers((self.header_decl,)) else: self.modified = modified self._process_classes() self._process_inner_namespaces() Session.end()
def processLogin(): fbInfo = json.loads(flask.request.values['fbInfo']) userID = fbInfo.get(u'userID') if userID == None: return errorResponse('no userID') with rpool.get() as R: sessionLifetime = 86400 * 14 # 2weeks (skey, secr) = Session.createSession(R, userID, sessionLifetime) response = {} ret = flask.jsonify(**response) ret.set_cookie(u'skey', skey, sessionLifetime) ret.set_cookie(u'secr', secr, sessionLifetime) return ret
def processXHR(): try: # handler Dictionary xhrHandlers = { 'LOG_INIT': xhrLogInit, 'LOG_UPDATE': xhrLogUpdate, 'LOG_OLD': xhrLogOld, 'CMD': xhrCmd, 'CONFIG_GET': xhrConfigGet, 'CONFIG_SET_SERVER': xhrConfigSetServer, } # json으로 넘어온 request object 파싱 if (flask.request.method != 'GET') or ('req' not in flask.request.values): abort(500) return print( flask.request.values['req'] ) reqObject = json.loads(flask.request.values['req']) # cookie로부터 인증 정보를 수집 #app.logger.debug(" cookie - %s", str(flask.request.cookies)) userID = None print( flask.request.cookies ) sessionKey = flask.request.cookies.get('skey') secret = flask.request.cookies.get('secr') if sessionKey is not None and secret is not None: with rpool.get() as R: userID = Session.checkSession(R, sessionKey, secret) # 인증 정보가 없으면 에러 응답 if userID is None: response = { u'err': u'LOGIN_REQUIRED' } return flask.jsonify(**response) # 인증을 통과함. 정상 응답 return xhrHandlers[ reqObject['req'] ] (userID, reqObject) except: traceback.print_exc()
def decode_msg_15(self, raw_data): session = Session() client_id = self.decode_int("l", raw_data, 0) client_netid = self.decode_int("l", raw_data, 4) client_type = self.decode_int("b", raw_data, 8) logging.debug("ClientID: %d | CLientNetworkID: %d | ClientType: %d ", client_id, client_netid, client_type) offset = 9 if client_type is 1: client_name_len = self.decode_int("h", raw_data, offset) client_name = self.decode_string(raw_data, offset) client_hash = struct.unpack_from("<17s", raw_data, 11 + client_name_len) logging.debug("--- ClientName: %s (%d) | ClientHash: %s", client_name, client_name_len, str.upper(binascii.hexlify("".join(client_hash)))) offset = 28 + client_name_len; ip0 = self.decode_int("B", raw_data, offset) ip1 = self.decode_int("B", raw_data, offset+1) ip2 = self.decode_int("B", raw_data, offset+2) ip3 = self.decode_int("B", raw_data, offset+3) geoip = self.decode_int("B", raw_data, offset + 4) port = self.decode_int("H", raw_data, offset + 5) logging.debug("--- IP: %d.%d.%d.%d | geoip: %d | Port: %d ", ip0, ip1, ip2, ip3, geoip, port) offset += 7 connection_state = self.decode_int("B", raw_data, offset) offset += 1 logging.debug("--- ConnectionState: %d ", connection_state) if str(connection_state) in ("3", "5", "9"): rank = self.decode_int("l", raw_data, offset) logging.debug("--- Rank: %d ", rank) offset += 4 client_type = self.decode_int("b", raw_data, offset) offset += 1 logging.debug("--- ClientType: %d ", client_type) tag_list_len = self.decode_int("h", raw_data, offset) logging.debug("--- TagListLen: %d ", tag_list_len) offset += 2 for i in range(tag_list_len): tag_name_len = self.decode_int("h", raw_data, offset) tag_name = self.decode_string(raw_data, offset) offset += 2 + tag_name_len tag_type = self.decode_int("b", raw_data, offset) offset += 1 if str(tag_type) in ("0", "1", "3", "6"): tag_value = self.decode_int("l", raw_data, offset) offset += 4 elif tag_type is 2: tag_value_len = self.decode_int("h", raw_data, offset) tag_value = self.decode_string(raw_data, offset) offset += 2 + tag_value_len elif tag_type is 4: tag_value = self.decode_int("h", raw_data, offset) offset += 2 elif tag_type is 5: tag_value = self.decode_int("b", raw_data, offset) offset += 1 logging.debug("--- Tag %d -> %s = %s", i, tag_name, str(tag_value)) client_name_len = self.decode_int("h", raw_data, offset) client_name = self.decode_string(raw_data,offset) offset += 2 + client_name_len logging.debug("--- ClientName: %s", client_name) client_rating = self.decode_int("l", raw_data, offset) offset += 4 logging.debug("--- ClientRating: %d", client_rating) client_software_len = self.decode_int("h", raw_data, offset) client_software = self.decode_string(raw_data, offset) offset += 2 + client_software_len logging.debug("--- ClientSoftware: %s", client_software) downloaded = self.decode_int("L", raw_data, offset) offset += 8 uploaded = self.decode_int("L", raw_data, offset) offset += 8 logging.debug("--- Downloaded: %d | Uploaded: %d", downloaded, uploaded) upload_filename_len = self.decode_int("h", raw_data, offset) upload_filename = self.decode_string(raw_data, offset) offset += 2 + upload_filename_len logging.debug("--- UploadFileName: %s", upload_filename) connected_time = self.decode_int("l", raw_data, offset) offset += 4 logging.debug("--- ConnectedTime: %d", connected_time) emule_mod_len = self.decode_int("h", raw_data, offset) emule_mod = self.decode_string(raw_data, offset) offset += 2 + emule_mod_len logging.debug("--- EMuleMod: %s", emule_mod) client_version_len = self.decode_int("h", raw_data, offset) client_version = self.decode_string(raw_data, offset) offset += 2 + client_version_len logging.debug("--- ClientVersion: %s", client_version) sui_verified = self.decode_int("b", raw_data, offset) logging.debug("--- SuiVerified: %d", sui_verified) if downloaded is not 0 or uploaded is not 0: logging.debug(('ClientID: %d | ClientName: %s | ' 'ClientIP: %d.%d.%d.%d | ClientPort: %d | ' 'ClientSoftware: %s | ConnectionState: %d | ' 'FileName: %s | Down: %d | Up: %d '), client_id, client_name, ip0, ip1, ip2, ip3, port, client_software, connection_state, upload_filename, downloaded, uploaded) session.address.ip = "%d.%d.%d.%d" % (ip0, ip1, ip2, ip3) session.address.port = port session.downloaded = downloaded session.uploaded = uploaded session.source.id = client_id if client_type==0: session.kind = "lowID" else: session.kind = "highID" return session
form = cgi.FieldStorage() if form.has_key( "message" ): # create DOM for error message document = implementation.createDocument( None, None, None ) error = document.createElement( "error" ) message = document.createElement( "message" ) message.appendChild( document.createTextNode( form[ "message" ].value ) ) error.appendChild( message ) document.appendChild( error ) # process against XSLT style sheet processor = Processor.Processor() style = open( Session.getClientType()[ 0 ] + "/error.xsl" ) processor.appendStylesheetStream( style ) results = processor.runNode( document ) style.close() # display content type and processed XML print Session.getContentType() + results ########################################################################## # (C) Copyright 2002 by Deitel & Associates, Inc. and Prentice Hall. # # All Rights Reserved. # # # # DISCLAIMER: The authors and publisher of this book have used their # # best efforts in preparing the book. These efforts include the # # development, research, and testing of the theories and programs # # to determine their effectiveness. The authors and publisher make #
def print_and_clear_ignored_symbols_registry(): Session.print_ignored_symbols_registry() Session.clear_ignored_symbols_registry()
# Fig. 23.12: displayBook.py # Retrieve one book's XML representation, convert # to required format using browser-specific XSLT # stylesheet and display results. import cgi import sys import Session from xml.xslt import Processor from xml.dom.DOMImplementation import implementation form = cgi.FieldStorage() # ISBN has not been specified if not form.has_key( "isbn" ): Session.redirect( "error.py?message=No+ISBN+given" ) sys.exit() # load Session try: session = Session.Session() except Session.SessionError, message: # invalid/no session ID Session.redirect( "error.py?message=%s" % message ) sys.exit() titles = session.data[ "titles" ] # get titles session.data[ "bookToAdd" ] = None # book has not been found # locate Book object for selected book for book in titles:
def run(k1, k2, listsize, reco_type): if reco_type == 'tf': Session.run(k1, k2, listsize, False, False, 'tf') if reco_type == 'idf': Session.run(k1, k2, listsize, True, False, 'idf') if reco_type == 'keywords': Keywords.run(k1, k2, listsize, 'keywords') if reco_type == 'session': Session.run(k1, k2, listsize, False, True, 'session') if reco_type == 'mailinglist': MailingListRecommendation.run(k1, k2, listsize, 'mailinglist') if reco_type == 'all': Keywords.run(k1, k2, listsize, 'keywords') Session.run(k1, k2, listsize, False, True, 'session') Session.run(k1, k2, listsize, False, False, 'tf') Session.run(k1, k2, listsize, True, False, 'idf') MailingListRecommendation.run(k1, k2, listsize, 'mailinglist')
def generate(self): Session.begin(self.header_jar) if self._require_wrapper_class(): self.block.write_code("class %s;" % self.get_wrapt_class_name()) self.block.append_blank_line() self.block.write_code(Code.Snippets.pyobj_decl % { "WRAPT": self.get_wrapt_class_name(), "PYTYPE_NAME": self.namer.pytype(self.full_name), "PYOBJ_NAME": self.namer.pyobj(self.full_name), "BASE_PTR_FIXER": self.namer.base_ptr_fixer(self.full_name), }) if not self.fptrs.empty(): self.fptrs.generate(self.block) self.block.append_blank_line() if self._require_wrapper_class(): self._generate_wrapper_class() if not self.enum_class: self._generate_borrower() if self.copy_ready(): self._generate_copyer() # Use a dummy subclass as method holder to invoke protected members method_holder = self.namer.method_holder(self.full_name) if self.allows_subclassing() or self.enum_class: if not self.enum_class: method_wrapper_base = self.full_name else: method_wrapper_base = self.nester or "pbpp::ScopedEnumDummy" self.block.write_code("struct %s : %s {" % ( method_holder, method_wrapper_base )) else: self.block.write_code("struct %s {" % method_holder) self.block.append_blank_line() self._generate_constructors() self._generate_destructor() self._generate_methods() self._generate_enums() self._generate_fields() self.block.write_code(Code.Snippets.method_holder_end % { "METHOD_HOLDER": self.namer.method_holder(self.full_name), "METHODS_TABLE": self.namer.methods_table(self.full_name), "GETSET_TABLE": self.namer.getset_table(self.full_name), "BASES_REGISTER": self.namer.bases_register(self.full_name), }) self._generate_methods_table() self._generate_getset_table() self._generate_pytypeobject() self._generate_base_ptr_fixer() self._generate_bases_register() self._generate_register() Session.end() # TODO: Why can't do this in ctor? self.header_jar.add_headers(self.header_provider.klass(self.full_name)) if self._require_wrapper_class(): self.header_jar.add_headers(("<typeinfo>",)) memblock = CodeBlock.CodeBlock() memblock.write_code(self.header_provider.pch()) memblock.write_code(self.header_jar.concat_sorted()) memblock.append_blank_line() # TODO: a dirty trick self.block.lines = memblock.lines + self.block.lines self.modified = False
session = None # Session not yet created # attempt to create Session three times for i in range( 3 ): # create new Session try: session = Session.Session( 1 ) # ID already exists except Session.IDError: time.sleep( 0.1 ) # wait 0.1 seconds -- try again # missing content type except Session.SessionError, message: Session.redirect( "error.py?message=%s" % message ) sys.exit() else: break # Session created successfully # if successful, save Session and re-direct to allBooks.py if session: nextPage = "allBooks.py?ID=%s" % session.data[ "ID" ] session.saveSession() Session.redirect( nextPage ) else: Session.redirect( "error.py?message=Unable+to+create+Session" ) ########################################################################## # (C) Copyright 2002 by Deitel & Associates, Inc. and Prentice Hall. #
def generate(self, outdir, ext): for submodule in self.submodules.values(): submodule.generate(outdir, ext) full_name = self._pyside_full_name() output_path = "%s%s%s.py%s" % ( outdir, os.path.sep, full_name, ext ) if self.is_root(): self._copy_helpers(outdir) if not self.modified and os.path.exists(output_path): return # Return this function with care: # Remember to call Session.end() Session.begin(self.header_jar) fp_mem_block = CodeBlock.CodeBlock() fptrs = Fptr.FptrManager() self.free_functions.collect_function_pointer_defs(fptrs) if not fptrs.empty(): fptrs.generate(fp_mem_block) fp_mem_block.append_blank_line() fp_mem_block.append_blank_line() ff_mem_block = CodeBlock.CodeBlock() ff_table_mem_block = CodeBlock.CodeBlock() self.free_functions.generate_methods(ff_mem_block, self.namer, self) self.free_functions.generate_methods_table(ff_table_mem_block, self.namer, self) template_args = { "MNAME": self.name, "MNAME_FULL": full_name, "MOD_REGISTER": self.get_register_name(), "HEADERS": self.header_jar.concat_sorted(), "FPTRS": fp_mem_block.flush(), "FREE_FUNCTIONS": ff_mem_block.flush(), "METHODS_TABLE": ff_table_mem_block.flush(), } block = CodeBlock.CodeBlock() block.write_code(self.header_provider.pch()) with open(os.path.dirname(__file__) + "/Code/Header.inl") as f: block.write_code(f.read() % template_args) self._generate_global_constants_wrapper(block) self._generate_enums_register(block) module_ptr = self.namer.mod_ptr_name(full_name) block.write_code(Code.Snippets.define_module_ptr.format(module_ptr)) block.write_code(Code.Snippets.module_register_header % template_args) block.indent() block.write_code(self.namer.globals_register(full_name) + "(m);") block.write_code(self.namer.enums_register(full_name) + "(m);") block.append_blank_line() for submodule in self.submodules.values(): register = submodule.get_register_name() block.write_code("PyObject *%s(PyObject *parent);" % register) if len(self.submodules) > 0: block.append_blank_line() for submodule in self.submodules.values(): block.write_code(submodule.get_register_name() + "(m);") if len(self.submodules) > 0: block.append_blank_line() for cls in self.classes.values(): cls.mod = 'm' if self.is_root() else module_ptr if self.is_root(): self._register_classes(block, outdir, ext) block.write_code(module_ptr + " = m;") block.write_code("return m;") block.unindent() block.write_code("}") if self.is_root(): with open(os.path.dirname(__file__) + "/Code/RootMod.inl") as f: block.write_code(f.read() % self.name) ns = self._get_cxx_namespace() or self.name content = self.blacklist.hook_write(ns, block.flush()) Util.smart_write(output_path, content) self.modified = False Session.end()
threshold = 30 # 30 minutes threshold fname = sys.argv[1] # file with logs of only single user lines = readFile(fname) matrix_fname = list(reversed(fname.split('/')))[0] #Input : "xdir/../.../log/user1" , output: 'user1' matrix_fname += "_matrix" #user1_matrix matrix_dir = "matrix_dir" createDir(matrix_dir) #createDir creates (if not exists) matrix_dir in current directory. createDir("waitTimeMatrix_dir") matrix_fname = matrix_dir+"/"+matrix_fname # f = open(matrix_fname,'w') # f.close() prevtime = -1 curSession = Session() # print "New Session..." for line in lines: arr = getArray(line) curTime = getTime(arr) if prevtime==-1: prevtime = curTime statusCode = getStatusCode(arr) timeDiff = (curTime - prevtime).total_seconds() #Time differnce in seconds if(timeDiff<0): print "Warning : Time differnce should not be negative!" exit(0) if (timeDiff/60.0 > threshold):
#!/usr/local/bin/python # Fig. 23.16: viewCart.py # Generate XML representing cart, convert # to required format using browser-specific XSLT # style sheet and display results. import sys import Session from xml.xslt import Processor from xml.dom.DOMImplementation import implementation # load Session try: session = Session.Session() except Session.SessionError, message: # invalid/no session ID Session.redirect( "error.py?message=%s" % message ) sys.exit() cart = session.data[ "cart" ] total = 0 # total for all ordered items # generate XML representing cart object document = implementation.createDocument( None, None, None ) cartNode = document.createElement( "cart" ) document.appendChild( cartNode ) # add XML representation for each cart item for cartItem in cart.values(): # get book data, calculate subtotal and total book = cartItem.item
print 'save world to disk' util.toFile('test', world.toTag())''' print 'loading world from file' worldtag = util.fromFile('test') world = World.readWorld(worldtag) world.players = [player] world.crates = [crate] Session = Session.Session() Session.worlds.append(world) while 1: Session.update() ''' world.buildDrawList() world.buildEntList() screen.fill((255,255,255)) world.draw(screen) fps = str(int(round(clock.get_fps()))) fpsSurf = font.render(fps, True, (0,0,0)) fpsRect = fpsSurf.get_rect() fpsRect.topleft = [10,10] screen.blit(fpsSurf, fpsRect)
#!/usr/bin/env python from Session import * class User(object): user_name = None user_id = None def __init__(self, name, id): self.user_name = name self.user_id = id user = User("vivian",2) session = Session(user) print session.getUserid() condition = session.getState() print(condition) if condition: id = session.getUserid() user = User("vivian", id) print(user.user_id) print("cookie works!") else: user = User("vivian", 1) print(user.user_id)
def write_args_parsing_code(self, block, namer, enable_kw, err_return, pyside_debug_name): error_handler_label = "PBPP__ARGS_PARSING_ERROR_HANDLER_" + str(block.size()) require_error_handler_label = False to_cxx = [] count0 = 0 for arg in self.args: if arg.type.cvt: block.write_code(arg.type.cvt.args_parsing_declare_vars(arg.type, arg.name, arg.defv)) goto_error_return = "goto %s;" % error_handler_label if arg.type.cvt.args_parsing_require_error_handling(arg.type): require_error_handler_label = True extracting_code = arg.type.cvt.args_parsing_extracting_code( arg.type, arg.name, arg.defv, goto_error_return, namer ) if len(extracting_code) > 0: to_cxx += extracting_code.split('\n') Session.header_jar().add_headers(arg.type.cvt.additional_headers(arg.type)) elif arg.type.is_built_in(): if arg.type.is_bool(): block.write_code("PyObject *py__%s = nullptr;" % arg.name) if arg.defv is None: extracting_code = Types.extract_as_bool("py__%s" % arg.name) to_cxx.append(arg.type.declare_var(arg.name, extracting_code)) else: to_cxx.append(arg.type.declare_var(arg.name, arg.defv)) extracting_code = (Code.Snippets.check_and_extract_as_bool % { "VAR_NAME": arg.name }).split('\n') to_cxx += extracting_code else: block.write_code(arg.type.declare_var(arg.name, arg.defv)) elif arg.type.is_ref(): if not arg.type.is_trivial(): pytype = namer.pytype(arg.type.intrinsic_type()) block.write_code("extern PyTypeObject %s;" % pytype) block.write_code("PyObject *py__%s = nullptr;" % arg.name) cpp_ptr_type = arg.type.ref_to_ptr() if arg.type.is_trivial(): capsule_ensure_reference = (Code.Snippets.capsule_ensure_reference % { "VAR_NAME": arg.name, "CAP_NAME": arg.type.decl_no_const(), "ERROR_RETURN": "goto %s;" % error_handler_label, }).split('\n') require_error_handler_label = True if arg.defv is None: to_cxx += capsule_ensure_reference init_expr = '*((%s) PyCapsule_GetPointer(py__%s, "%s"))' % ( (cpp_ptr_type.decl(), arg.name, arg.type.decl_no_const(),) ) to_cxx.append(arg.type.declare_var(arg.name, init_expr)) else: var_ptr = "py_cxx_%s_ptr" % arg.name to_cxx.append(cpp_ptr_type.declare_var(var_ptr, "&(%s)" % arg.defv)) to_cxx.append("if (py__%s) {" % arg.name) to_cxx.append(">>>") to_cxx += capsule_ensure_reference to_cxx.append(var_ptr + ' = (%s) PyCapsule_GetPointer(py__%s, "%s")' % ( cpp_ptr_type, arg.name, arg.type.decl_no_const(), )) to_cxx.append("<<<") to_cxx.append("}") to_cxx.append(arg.type.declare_var(arg.name, '*' + var_ptr)) else: # reference to class if arg.defv is None: init_expr = '*' + Code.Snippets.external_type_real_ptr % { "CLASS": arg.type.intrinsic_type(), "PYOBJ_PTR": "py__" + arg.name } to_cxx.append(arg.type.declare_var(arg.name, init_expr)) else: defv_rv = "py_cxx_%s_defv_rv" % arg.name var_ptr = "py_cxx_%s_ref2ptr" % arg.name to_cxx.append("auto &&%s = %s;" % (defv_rv, arg.defv)) to_cxx.append(cpp_ptr_type.declare_var(var_ptr, '&' + defv_rv)) to_cxx.append("if (py__%s) {" % arg.name) to_cxx.append(">>>") to_cxx.append(var_ptr + ' = ' + Code.Snippets.external_type_real_ptr % { "CLASS": arg.type.intrinsic_type(), "PYOBJ_PTR": "py__" + arg.name } + ';') to_cxx.append("<<<") to_cxx.append("}") to_cxx.append(arg.type.declare_var(arg.name, '*' + var_ptr)) elif arg.type.decl_no_const() == "PyObject *": init_expr = "nullptr" if arg.defv is not None: init_expr = arg.defv block.write_code(arg.type.declare_var(arg.name, init_expr)) else: # pointer or argument pass by value if arg.type.is_trivial(): # trivial pointer pytype = "PyCapsule_Type" block.write_code("PyObject *py__%s = nullptr;" % arg.name) extracting_code = '(%s) PyCapsule_GetPointer(py__%s, "%s")' % ( (arg.type.decl(), arg.name, arg.type.decl_no_const(),) ) to_cxx.append(arg.type.declare_var(arg.name, arg.defv if arg.defv else "nullptr")) else: pytype = namer.pytype(arg.type.intrinsic_type()) block.write_code("extern PyTypeObject %s;" % pytype) block.write_code("PyObject *py__%s = nullptr;" % arg.name) extracting_code = Code.Snippets.external_type_real_ptr % { "CLASS": arg.type.intrinsic_type(), "PYOBJ_PTR": "py__" + arg.name } if not arg.type.is_ptr(): # args pass by value extracting_code = '*' + extracting_code if not arg.defv: init_expr = extracting_code extracting_code = None # DONE processing else: init_expr = arg.defv to_cxx.append(arg.type.declare_var(arg.name, init_expr)) else: to_cxx.append(arg.type.declare_var(arg.name, "nullptr")) if arg.type.is_ptr() or arg.defv is not None: memblock = CodeBlock.CodeBlock() if arg.defv is not None: memblock.write_code("if (py__%s) {" % arg.name) memblock.indent() if arg.type.is_ptr(): memblock.write_code("if (py__%s != Py_None) {" % arg.name) memblock.indent() memblock.write_code(Code.Snippets.extract_pointer % { "VAR_NAME": arg.name, "PYTYPE": pytype, "POINTER_TYPE": arg.type.intrinsic_type(), "EXTRACTING_CODE": extracting_code, "ERROR_HANDLER": "goto %s;" % error_handler_label, }) require_error_handler_label = True memblock.unindent() memblock.write_code("}") else: memblock.write_code("%s = %s;" % (arg.name, extracting_code)) if arg.defv is not None: memblock.unindent() memblock.write_code('}') to_cxx += memblock.lines if count0 < len(to_cxx): to_cxx.append("") count0 = len(to_cxx) if enable_kw: kws = "nullptr" if not self.empty(): kws = ", ".join(['"%s"' % kw for kw in self.get_keywords()] + ["nullptr"]) block.write_code("const char *py_keywords[] = { %s };" % kws) block.append_blank_line() parser_idecl = self.build_parser_idecl(namer=namer, enable_kw=enable_kw, func_name=pyside_debug_name) block.write_error_check("!" + parser_idecl, handler=err_return, handler_label=error_handler_label if require_error_handler_label else None) block.append_blank_line() if len(to_cxx) > 0: block.write_lines(to_cxx)
def get_build_value_idecl(self, var_name, py_var_name=None, namer=None, raii=False): assert not self.is_pyobject_ptr() if py_var_name is None: if '.' in var_name: intrinsic_name = var_name[(var_name.rindex('.') + 1):] elif "->" in var_name: intrinsic_name = var_name[(var_name.rindex('>') + 1):] else: intrinsic_name = var_name py_var_name = "py_" + intrinsic_name if self.cvt: Session.header_jar().add_headers(self.cvt.additional_headers(self)) return self.cvt.build(self, var_name, py_var_name, namer, raii) elif self.is_built_in(): if self.is_enum(): var_name = "static_cast<int>(%s)" % var_name builder = _built_in["int"]["builder"] else: builder = _built_in[self.decl_no_const()]["builder"] if raii: return "pbpp::PyObjectPtr %s(%s(%s));" % (py_var_name, builder, var_name) else: return "PyObject *%s = %s(%s);" % (py_var_name, builder, var_name) elif self.is_ptr_or_ref(): if self.is_ref(): ptr = "&%s" % var_name if var_name.isalnum() else "&(%s)" % var_name ref = var_name else: ptr = var_name ref = "*%s" % var_name if var_name.isalnum() else "*(%s)" % var_name if self.is_trivial(): template_args = { "VAR": ref if self.is_ref() else ptr, "PY_VAR_NAME": py_var_name, "TYPE_STR": self.decl_no_const(), } if self.is_ref(): if raii: template = Code.Snippets.PyCapsule_New_RAII_Ref else: template = Code.Snippets.PyCapsule_New_Ref else: if raii: template = Code.Snippets.PyCapsule_New_RAII_Ptr else: template = Code.Snippets.PyCapsule_New_Ptr return template % template_args else: assert namer is not None py_raw_ptr = py_var_name[:2] + "_raw" + py_var_name[2:] boilerplate = Code.Snippets.borrow_from_ptr if self.is_ref(): if raii: boilerplate = Code.Snippets.borrow_from_ref_raii else: boilerplate = Code.Snippets.borrow_from_ref ret = boilerplate % { "VAR": var_name, "PY_VAR_NAME": py_var_name, "PY_RAW_PTR": py_raw_ptr, "PTR": ptr, "REF": ref, "CLASS": self.intrinsic_type(), "BORROWER": namer.borrower(self.intrinsic_type()), } if self.is_ptr(): if raii: ret += "\npbpp::PyObjectPtr %s(%s);" %(py_var_name, py_raw_ptr) else: ret += "\nPyObject *%s = %s;" %(py_var_name, py_raw_ptr) return ret else: assert namer is not None boilerplate = Code.Snippets.copy_raii if raii else Code.Snippets.copy return boilerplate % { "VAR": var_name, "PY_VAR_NAME": py_var_name, "CLASS": self.intrinsic_type(), "COPYER": namer.copyer(self.intrinsic_type()), }
def __init__(self, root, node, module, dummy_def=None): assert node is not None or dummy_def is not None # Only effective while processing self.root = root self.node = node self.namer = module.namer self.header_provider = module.header_provider self.flags_assigner = module.flags_assigner self.blacklist = module.blacklist self.all_bases = None self.master_bases = None self.has_public_copy_ctor = True self.final = False # No accessible canonical ctors -> disallow subclassing # `canonical ctor` refers to a ctor that is not a copy ctor self.no_accessible_canonical_ctors = False # If true, requires a wrapper class # We only save constructors' params, so we can't determine # whether the class has any protected constructor when # generating the output self.has_protected_ctor = False # Instantiatable (new-able) != delete-able self.dtor_access_type = Access.PUBLIC self.protected_nonvirtual_members = set() self.public_nonvirtual_methods = [] self.virtual_members = [] self.base_vm_collected = False self.enums = Enum.Enum() self.ctors = [] self.methods = MethodJar.MethodJar() self.fields = [] self.fptrs = Fptr.FptrManager() self.header_jar = HeaderJar.HeaderJar() self.header_jar.add_headers(("_Python.hxx", "_Common.hxx",)) if module.header_decl: self.header_jar.add_headers((module.header_decl,)) # These properties only accessed by the Module class self.modified = True self.m = None # For temporary use only, avoid passing it everywhere self.block = CodeBlock.CodeBlock() if dummy_def is not None: self.name = dummy_def.name self.full_name = dummy_def.full_name self.enum_class = dummy_def.enum_class self.nester = dummy_def.nester self.direct_bases = [] # TODO: namespace alias if (not dummy_def.namespace and not dummy_def.nester and not dummy_def.enum_class): assert self.name == self.full_name self.header_jar.add_global("%s %s;" % ( "struct" if dummy_def.is_struct else "class", self.name )) # Instantiating, destroying, copying or inheriting # a dummy class (object) is not allowed self.has_public_copy_ctor = False self.final = True self.no_accessible_canonical_ctors = True self.dtor_access_type = Access.PRIVATE else: Session.begin(self.header_jar) self.name = node.attrib["name"] self.full_name = node.attrib["demangled"] self.enum_class = False self.nester = self._get_nester_class() self.direct_bases = self._collect_direct_bases() self.final = node.attrib.get("final") == "1" self._constructors() self._destructor() # Check dtor's access type self._methods() self._enums(module) self._fields() Session.end()
def get_extractor_code(self, var_name, py_var_name, error_return, namer=None): block = CodeBlock.CodeBlock() if self.is_ptr(): block.write_code(self.declare_var(var_name, "nullptr")) block.write_code("if (%s != Py_None) {" % py_var_name) block.indent() if self.cvt is not None: Session.header_jar().add_headers(self.cvt.additional_headers(self)) negative_checker = self.cvt.negative_checker(self, "(PyObject *) " + py_var_name) extracting_code = self.cvt.extracting_code(self, var_name, py_var_name, error_return, namer) elif self.is_built_in(): if self.is_enum(): dummy_type = "int" else: dummy_type = self.decl_no_const() negative_checker = "!%s((PyObject *) %s)" % (_built_in[dummy_type]["checker"], py_var_name) if self.is_bool(): extracting_code = self.declare_var(var_name, extract_as_bool(py_var_name)) else: extracting_code = Code.Snippets.extract_builtin_type % { "CAST_ENUM": "(%s) " % self.decl() if self.is_enum() else "", "EXTRACTOR": _built_in[dummy_type]["extractor"], "VAR_TYPE": self.decl(), "PY_VAR_NAME": py_var_name, "VAR_NAME": var_name, } elif self.is_trivial(): negative_checker = '!PyCapsule_IsValid(%s, "%s")' % ( py_var_name, self.decl_no_const(), ) extracting_code = '%s = (%s) PyCapsule_GetPointer(%s, "%s");' % ( var_name, self.decl(), py_var_name, self.decl_no_const(), ) else: pytype = namer.pytype(self.intrinsic_type()) block.write_code("extern PyTypeObject %s;" % pytype) negative_checker = "!PyObject_TypeCheck(%s, &%s)" % (py_var_name, pytype) if not self.is_ptr(): extracting_code = self.declare_var(var_name, '*' + Code.Snippets.external_type_real_ptr % { "CLASS": self.intrinsic_type(), "PYOBJ_PTR": py_var_name, }) else: extracting_code = (var_name + " = " + Code.Snippets.external_type_real_ptr % { "CLASS": self.intrinsic_type(), "PYOBJ_PTR": py_var_name, } + ';') block.write_code(Code.Snippets.single_var_extractor % { "NEGATIVE_CHECKER": negative_checker, "VAR_TYPE": self.decl(), "PY_VAR_NAME": py_var_name, "VAR_NAME": var_name, "ERROR_RETURN": error_return, "EXTRACTING_CODE": extracting_code, }) if self.is_ptr(): block.unindent() block.write_code('}') return block.flush()
def _test(): import CodeBlock import Converters import HeaderJar header_jar = HeaderJar.HeaderJar() Session.begin(header_jar) Converters.add(Converters.WcsConv()) tk = TupleAndKeywords() tk.add_parameter(Argument.Argument(Types.Type(("int", "*",), 1, "FundamentalType"), "foo")) tk.add_parameter(Argument.Argument(Types.Type(("double", "&",), 2, "FundamentalType"), "bar")) tk.add_parameter(Argument.Argument(Types.Type(("long unsigned int", "&", "const",), 3, "FundamentalType"), "xyz")) tk.add_parameter(Argument.Argument(Types.Type(("X", "const", "&",), 4, "Class"), "x")) tk.add_parameter(Argument.Argument(Types.Type(("Y", "*",), 5, "Class"), "y")) tk.add_parameter(Argument.Argument(Types.Type(("Z",), 6, "Class"), "z")) tk.add_parameter(Argument.Argument(Types.Type(("bool",), 7, "FundamentalType"), "b")) tk.add_parameter(Argument.Argument(Types.Type(("wchar_t", "const", "*",), 8, "PointerType"), "str")) print(tk.get_fmt_specifier()) print(tk.get_keywords()) print(tk.build_function_signature_parameter_list()) from Module import PythonNamer namer = PythonNamer() print(tk.build_parser_idecl(namer=namer)) _print_empty_line() block = CodeBlock.CodeBlock() tk.write_args_parsing_code(block, namer, True, "return nullptr;", "<TEST>") print(block.flush()) _print_empty_line() _print_empty_line() tk = TupleAndKeywords() tk.add_parameter(Argument.Argument(Types.Type(("int", "*",), 1, "FundamentalType"), "foo", "nullptr")) tk.add_parameter(Argument.Argument(Types.Type(("double", "&",), 2, "FundamentalType"), "bar", "PI")) tk.add_parameter(Argument.Argument(Types.Type(("long unsigned int", "&", "const",), 3, "FundamentalType"), "xyz", "MAXINT")) tk.add_parameter(Argument.Argument(Types.Type(("X", "const", "&",), 4, "Class"), "x", "_x")) tk.add_parameter(Argument.Argument(Types.Type(("Y", "*",), 5, "Class"), "y", "_py")) tk.add_parameter(Argument.Argument(Types.Type(("Z",), 6, "Class"), "z", "Z(1990)")) tk.add_parameter(Argument.Argument(Types.Type(("bool",), 7, "FundamentalType"), "b", "true")) tk.add_parameter(Argument.Argument(Types.Type(("wchar_t", "const", "*",), 8, "PointerType"), "str", 'L"Hello world!"')) tk.write_args_parsing_code(block, namer, True, "return nullptr;", "<TEST>") print(block.flush()) integer = Types.Type(("int",), 99, "FundamentalType") Converters.add(Converters.ListConv(integer)) tk = TupleAndKeywords() tk.add_parameter(Argument.Argument(Types.Type(("std::vector<int>", "const", "&",), 0, "Class"), "vi", "_vi")) tk.write_args_parsing_code(block, namer, True, "return nullptr;", "<TEST>") print(block.flush()) K = Types.Type(("wchar_t", "const", "*",), 111, "PointerType") V = Types.Type(("wxColour", "*",), 112, "PointerType") Converters.add(Converters.DictConv(K, V)) tk = TupleAndKeywords() tk.add_parameter(Argument.Argument(Types.Type(("std::map<wchar_t const *, wxColour *>", "&",), 0, "Class"), "m")) tk.write_args_parsing_code(block, namer, True, "return nullptr;", "<TEST>") print(block.flush())