def _populate_titles(self): kwargs = {} if not self._locale.fallthrough: kwargs['country'] = self._locale.country return Request('movie/{0}/alternative_titles'.format(self.id), **kwargs)
def searchPerson(query, adult=False): return PeopleSearchResult( Request('search/person', query=query, include_adult=adult))
def searchList(query, adult=False): ListSearchResult(Request('search/list', query=query, include_adult=adult))
return template(tpl_name, **tplvars) return result return wrapper return decorator from template import MakoTemplate, CheetahTemplate, Jinja2Template, SimpleTALTemplate mako_view = functools.partial(view, template_adapter=MakoTemplate) cheetah_view = functools.partial(view, template_adapter=CheetahTemplate) jinja2_view = functools.partial(view, template_adapter=Jinja2Template) simpletal_view = functools.partial(view, template_adapter=SimpleTALTemplate) from const import DEBUG, HTTP_CODES #: A thread-save instance of :class:`Request` representing the `current` request. request = Request() #: A thread-save instance of :class:`Response` used to build the HTTP response. response = Response() #: A thread-save namepsace. Not used by Mole. local = threading.local() # Initialize app stack (create first empty Mole app) # BC: 0.6.4 and needed for run() app = default_app = AppStack() app.push() #---加入一个app实例
def handle_one_request(self): response = None logger = get_logger() try: self.close_connection = False request_line_is_valid = self.get_request_line() if self.close_connection: return request_is_valid = self.parse_request() if not request_is_valid: #parse_request() actually sends its own error responses return self.server.rewriter.rewrite(self) request = Request(self) response = Response(self, request) if not request_line_is_valid: response.set_error(414) response.write() return logger.debug("%s %s" % (request.method, request.request_path)) handler = self.server.router.get_handler(request) if self.server.latency is not None: if callable(self.server.latency): latency = self.server.latency() else: latency = self.server.latency logger.warning("Latency enabled. Sleeping %i ms" % latency) time.sleep(latency / 1000.) if handler is None: response.set_error(404) else: try: handler(request, response) except HTTPException as e: response.set_error(e.code, e.message) except Exception as e: if e.message: err = [e.message] else: err = [] err.append(traceback.format_exc()) response.set_error(500, "\n".join(err)) logger.debug( "%i %s %s (%s) %i" % (response.status[0], request.method, request.request_path, request.headers.get('Referer'), request.raw_input.length)) if not response.writer.content_written: response.write() # If we want to remove this in the future, a solution is needed for # scripts that produce a non-string iterable of content, since these # can't set a Content-Length header. A notable example of this kind of # problem is with the trickle pipe i.e. foo.js?pipe=trickle(d1) if response.close_connection: self.close_connection = True if not self.close_connection: # Ensure that the whole request has been read from the socket request.raw_input.read() except socket.timeout, e: self.log_error("Request timed out: %r", e) self.close_connection = True return
def __call__(self, http_request=None, **urlparameters): sapi_request = SAPIRequest(self, http_request) request_items = dict(sapi_request.REQUEST.items()) request_items.update(urlparameters) if SIMPLEAPI_DEBUG and SIMPLEAPI_DEBUG_LEVEL == 'call': self.logger.info(pprint.pformat(request_items)) self.profile_start() version = request_items.pop('_version', 'default') callback = request_items.pop('_callback', None) output_formatter = request_items.pop('_output', None) # let's activate JSONP automatically if _callback is given if callback and not output_formatter: output_formatter = 'jsonp' elif not output_formatter: output_formatter = 'json' input_formatter = request_items.pop('_input', 'value') wrapper = request_items.pop('_wrapper', 'default') mimetype = request_items.pop('_mimetype', None) input_formatter_instance = None output_formatter_instance = None wrapper_instance = None try: try: version = int(version) except (ValueError, TypeError): pass if not self.nmap.has_key(version): # continue with wrong version to get the formatters/wrappers # raise the error later! namespace = self.nmap['default'] else: namespace = self.nmap[version] # check input formatter if input_formatter not in namespace['input_formatters']: raise RequestException(u'Input formatter not allowed or ' \ 'unknown: %s' % input_formatter) # get input formatter input_formatter_instancec = namespace['input_formatters'][ input_formatter](sapi_request, callback) # check output formatter if output_formatter not in namespace['output_formatters']: raise RequestException(u'Output formatter not allowed or ' \ 'unknown: %s' % output_formatter) # get output formatter output_formatter_instance = namespace['output_formatters'][ output_formatter](sapi_request, callback) # check wrapper if wrapper not in namespace['wrappers']: raise RequestException(u'Wrapper unknown or not allowed: %s' % \ wrapper) # get wrapper wrapper_instance = namespace['wrappers'][wrapper] # check whether version exists or not if not self.nmap.has_key(version): raise RouterException(u'Version %s not found (possible: %s)' % \ (version, ", ".join(map(lambda i: str(i), self.nmap.keys())))) request = Request( sapi_request=sapi_request, namespace=namespace, input_formatter=input_formatter_instancec, output_formatter=output_formatter_instance, wrapper=wrapper_instance, callback=callback, mimetype=mimetype, restful=self.restful, debug=self.debug, route=self, ignore_unused_args=self.ignore_unused_args, ) # map request items to the correct names wi = wrapper_instance(sapi_request=sapi_request) request_items = wi._parse(request_items) if not isinstance(request_items, (list, tuple, types.GeneratorType)): request_items = [ request_items, ] responses = [] for request_item in request_items: # clear session (except _internal) sapi_request.session.clear() # process request try: responses.append(request.process_request(request_item)) except (NamespaceException, RequestException, \ ResponseException, RouterException, FeatureException),e: response = Response( sapi_request, errors=e.message, output_formatter=output_formatter_instance, wrapper=wrapper_instance, mimetype=mimetype) responses.append(response) rm = ResponseMerger( sapi_request=sapi_request, responses=responses, ) http_response = rm.build()
from request import Request, Log import re import urllib import urllib.parse #Requête pour creer un compte (méthode Post) : req = Request(ssl=True, host='www.snipes.fr', debug=True) reponse = req.request('/registration', headers={ 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'DNT': '1', 'Pragma': 'no-cache', 'Upgrade-Insecure-Requests': '1', }) #Recupération du Token if reponse is None: print("ERROR") exit() matches = re.findall( r"<input type=\"hidden\" name=\"csrf_token\" value=\"*(.*)\"", reponse) print("le token vaut : {}.".format(matches[0])) csrf = matches[0] # Demande des parametres de creation du compte : prenom = input("\n saisissez un prenom: ") prenom = "dwfrm_profile_register_firstName=" + prenom
def similar(self): res = MovieSearchResult(Request('movie/{0}/similar_movies'\ .format(self.id)), locale=self._locale) res._name = 'Similar to {0}'.format(self._printable_name()) return res
def lists(self): res = ListSearchResult(Request('movie/{0}/lists'.format(self.id))) res._name = "Lists containing {0}".format(self._printable_name()) return res
def _populate_trailers(self): return Request('movie/{0}/trailers'.format(self.id), \ language=self._locale.language)
def _populate_translations(self): return Request('movie/{0}/translations'.format(self.id))
def _populate_releases(self): return Request('movie/{0}/releases'.format(self.id))
def _populate_keywords(self): return Request('movie/{0}/keywords'.format(self.id))
def _populate_cast(self): return Request('movie/{0}/casts'.format(self.id))
def __init__(self): self.request = Request() self.response = None
def _populate(self): return Request('collection/{0}'.format(self.id), \ language=self._locale.language)
# fetch the list of active servers client.fetchPeersList(tracker_server_address, bind_port) # if servers doesn't exist, use simple download if client.numPeerServers() == 0: print("No peer servers! Using default download...") download_object = DistributedDownloaderAndMerger(url) download_object.download() else: print("Peer Servers found! Distributing download...") # get the filesize req = Request() response = req.makeRequest(url, proxy=peerClientConfig.getProxy()) filesize = int(response.headers['Content-Length']) req.closeConnection(response) print("peer-client filesize: {}".format(filesize)) # get the download ranges to be assigned to each parts = client.numPeerServers() range_list = Calculation().get_download_ranges_list( 0, filesize - 1, parts) # connect with each server and send them the download details client.connectWithPeerServers(range_list, temp_dir) # wait for download to complete at each server # except main_thread, calling join() for each thread
def _populate_images(self): kwargs = {} if not self._locale.fallthrough: kwargs['language'] = self._locale.language return Request('collection/{0}/images'.format(self.id), **kwargs)
'r' : {'a1':[1.0], 'a2':[1.0],'u1':[0.8],'u2':[2.0]}, 'A' : {'a1': 1, 'a2': 10}, 'l_req' : {('a1','a2'): 1}, 'input_datarate' : 100, 'chain' : "a1.(u1,u2).a2"} req130 = {'UF' : {'a1':'BNG', 'a2':'CR','u1':'FW','u2':'CACHE','u3':'AV','u4':'DPI','u5':'VOPT'}, 'r' : {'a1':[1.0], 'a2':[1.0],'u1':[0.5],'u2':[1.0],'u3':[0.5],'u4':[1.0],'u5':[3.0]}, 'A' : {'a1': 11, 'a2': 9}, 'l_req' : {('a1','a2'): 1}, 'input_datarate' : 150, 'chain' : "a1.(u1,u2).u3.(u4,u5).a2"} if reqtype == 'mixed': request_list.append(Request(req140)) request_list.append(Request(req150)) request_list.append(Request(req160)) request_list.append(Request(req170)) request_list.append(Request(req171)) request_list.append(Request(req172)) request_list.append(Request(req180)) request_list.append(Request(req181)) elif reqtype == 'req150': request_list.append(Request(req150)) elif reqtype == 'req20': request_list.append(Request(req20)) elif reqtype == 'req20s': request_list.append(Request(req20)) request_list.append(Request(req21)) request_list.append(Request(req22))
def _populate(self): return Request('list/{0}'.format(self.id))
def logfile(self, curr_host=None): t_time_tid = self.__init_tid() lineId, tid, ipid = 0, 0, 0 for line in fileinput.input(self.log_file): lineId += 1 if line[-2:] == "\r\n": #将windows结尾格式改成Unix格式 line = line[:-2] + "\n" matchs = self.rePattern.match(line) if matchs != None: ip = matchs.group("ip") date = matchs.group("date") month = matchs.group("month") year = matchs.group("year") time = matchs.group("time") method = matchs.group("method") request = matchs.group("request") #query = matchs.group("query") status = matchs.group("status") bytes = matchs.group("bytes") referer = matchs.group("referer") agent = matchs.group("agent") # ------ t_time oDt = Parsetime(self.db, year, month, date, time) logdt = str(oDt.dt['stamp']) if t_time_tid.get(logdt, -1) == -1: oDt.new_time() tid = oDt.dt['stamp'] t_time_tid[logdt] = tid else: tid = t_time_tid.get(logdt) # ------- t_request #print query url = request request = url.split(' ') if (len(request) > 1): url = request[1] reqjson = { 'tid': tid, 'line': lineId, 'ip': ip, 'method': method, 'status': status, 'url': url, 'bytes': bytes } oReq = Request(self.db, reqjson) oReq.do_req(tid, ip) # ---- t_refer if int(status) == 200: oRefer = Referer(referer, curr_host) oRefer.do_refer(self.db, tid) oRefer.do_keyword(self.db, tid) # -----keyword oAgent = Agent(agent) oAgent.do_agent(self.db, tid) #break #print lineId self.db.commit() fileinput.close()
def _populate(self): return Request('configuration')
def start_request(self): url = "http://www.baidu.com" yield Request(url=url, method='GET', callback=self.start_parse)
return True def _btnWriteClick(self, event): if self._validIp(): self.path = askopenfilename(filetypes=[('All', '.*')], title="Write---->Server") Request().Put(self.path, self.txtIp.get()) def _btnReadClick(self, event): if self._validIp(): self.path = asksaveasfilename(filetypes=[('All', '.*')], title="Read<----Server") Request().Get(self.path, self.txtIp.get()) if __name__ == "__main__": app = InterfaceClient() app.title('Client TFTP') app.mainloop() k(self, event): if self._validIp(): self.path = askopenfilename(filetypes=[('All', '.*')], title="Write---->Server") Request().Put(self.path, self.txtIp.get()) def _btnReadClick(self, event): if self._validIp(): self.path = asksaveasfilename(filetypes=[('All', '.*')], title="Read<----Server") Request().Get(self.path, self.txtIp.get()) i
def _populate(self): return Request('account', session_id=self._session.sessionid)
def _btnWriteClick(self, event): if self._validIp(): self.path = askopenfilename(filetypes=[('All', '.*')], title="Write---->Server") Request().Put(self.path, self.txtIp.get())
def searchStudio(query): return StudioSearchResult(Request('search/company', query=query))
def _btnReadClick(self, event): if self._validIp(): self.path = asksaveasfilename(filetypes=[('All', '.*')], title="Read<----Server") Request().Get(self.path, self.txtIp.get())
def searchCollection(query, locale=None): return CollectionSearchResult(Request('search/collection', query=query), locale=locale)
def _populate(self): return Request('movie/{0}'.format(self.id), \ language=self._locale.language)