dict:\\n validate_type(str, path, \\\"path\\\")\\n validate_type(str, content_type, \\\"content_type\\\")\",\n \"def upload_file(local_file, remote_file, key_filename=None, hostname=None, username=None) -> None:\\n with get_sftp_session(hostname=hostname, username=username, key_filename=key_filename) as sftp:\\n _upload_file(sftp, local_file, remote_file)\",\n \"def post(self):\\n if validate(request.form):\\n handle_upload(request.files['qqfile'], request.form)\\n return make_response(200, {\\\"success\\\": True})\\n else:\\n return make_response(400, {\\\"error\\\": \\\"Invalid request\\\"})\",\n \"def upload_file(filename, server, account, projname, language=None,\\n username=None, password=None,\\n append=False, stage=False, date_format=None):\\n stream = transcode_to_stream(filename, date_format)\\n upload_stream(stream_json_lines(stream),\\n server, account, projname, language=language,\\n username=username, password=password,\\n append=append, stage=stage)\",\n \"def on_post(self, req, resp, account, container):\\n _handle_script_upload(req, resp, account, container)\",\n \"def upload(self, localfile: str, remotefile: str, overwrite: bool = True, permission: str = '', **kwargs):\\n valid = self._sb.file_info(remotefile, quiet = True)\\n\\n if valid is None:\\n remf = remotefile\\n else:\\n if valid == {}:\\n remf = remotefile + self._sb.hostsep + localfile.rpartition(os.sep)[2]\\n else:\\n remf = remotefile\\n if overwrite == False:\\n return {'Success' : False, \\n 'LOG' : \\\"File \\\"+str(remotefile)+\\\" exists and overwrite was set to False. Upload was stopped.\\\"}\\n\\n try:\\n fd = open(localfile, 'rb')\\n except OSError as e:\\n return {'Success' : False, \\n 'LOG' : \\\"File \\\"+str(localfile)+\\\" could not be opened. Error was: \\\"+str(e)}\\n\\n fsize = os.path.getsize(localfile)\\n\\n if fsize > 0:\\n code = \\\"filename _sp_updn '\\\"+remf+\\\"' recfm=N permission='\\\"+permission+\\\"';\\\"\\n ll = self.submit(code, 'text')\\n log1 = ll['LOG']\\n\\n self.stdin[0].send(str(fsize).encode()+b'tom says EOL=UPLOAD \\\\n')\\n\\n while True:\\n buf = fd.read1(32768)\\n sent = 0\\n send = len(buf)\\n blen = send\\n if blen == 0:\\n break\\n while send:\\n try:\\n sent = 0\\n sent = self.stdout[0].send(buf[blen-send:blen])\\n except (BlockingIOError):\\n pass\\n send -= sent\\n \\n code = \\\"filename _sp_updn;\\\"\\n else:\\n log1 = ''\\n code = \\\"\\\"\\\"\\n filename _sp_updn '\\\"\\\"\\\"+remf+\\\"\\\"\\\"' recfm=F encoding=binary lrecl=1 permission='\\\"\\\"\\\"+permission+\\\"\\\"\\\"';\\n data _null_;\\n fid = fopen('_sp_updn', 'O');\\n if fid then\\n rc = fclose(fid);\\n run;\\n filename _sp_updn;\\n \\\"\\\"\\\"\\n\\n ll2 = self.submit(code, 'text')\\n fd.close()\\n\\n return {'Success' : True, \\n 'LOG' : log1+ll2['LOG']}\",\n \"def test_post_file(self):\\n self._register_uri(httpretty.POST)\\n with open(self.test_file, 'rb') as in_file:\\n response = self.client.post(self.test_endpoint,\\n files={\\\"file\\\": in_file})\\n self.assertEqual(response, self.test_data)\\n body = str(self._last_request().body)\\n self.assertIn(\\\"Content-Disposition: form-data; \\\"+\\n \\\"name=\\\\\\\"file\\\\\\\"; filename=\\\\\\\"test_file.txt\\\\\\\"\\\", body)\\n self.assertIn(\\\"Test File\\\", str(body))\",\n \"def upload_file(\\n self, bucket_id: uplink.Path, filename: uplink.Path, file: uplink.Body\\n ):\\n pass\",\n \"def upload_file():\\n response = Response()\\n response.headers.add('Access-Control-Allow-Origin', request.headers.get(\\\"Origin\\\", None))\\n response.headers.add('Access-Control-Allow-Methods', 'GET,POST')\\n response.headers.add('Access-Control-Max-Age', '21600')\\n response.headers.add('Access-Control-Allow-Credentials', 'true')\\n response.headers.add('Access-Control-Allow-Headers', \\\"Origin, X-Requested-With, Content-Type, Accept\\\")\\n\\n size = 256, 256\\n if request.method == 'POST':\\n file = request.files['file']\\n if file and allowed_file(file.filename):\\n # Prevent dir traversal/NUL byte injection\\n filename = secure_filename(file.filename)\\n\\n if not os.path.exists(app.config['UPLOAD_FOLDER']):\\n os.makedirs(app.config['UPLOAD_FOLDER'])\\n\\n file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))\\n im = Image.open(os.path.join(app.config['UPLOAD_FOLDER'], filename))\\n im.thumbnail(size, Image.ANTIALIAS)\\n im.save(app.config['UPLOAD_FOLDER'] + '/small_' + filename, \\\"PNG\\\")\\n _upload_to_s3(filename)\\n _upload_to_s3('small_{}'.format(filename))\\n return response\",\n \"def upload(self, endpoint, path, name=None, mime_type=None):\\n url = f\\\"{self.url}/fileuploads/{endpoint}\\\"\\n self.log.debug(f\\\"uploading: {url!r}: {path!r}\\\")\\n \\n # determine filename (if unspecified)\\n if not name:\\n name = os.path.basename(path) \\n \\n # NOTE: JSS requires filename extension (or upload will fail)\\n if not os.path.splitext(name)[1]:\\n raise APIError(response, f\\\"missing file extension: {path!r}\\\")\\n \\n # determine mime-type of file (if unspecified)\\n if not mime_type:\\n mime_type = mime_type(path)\\n \\n with open(path, 'rb') as f:\\n # Example of posted data:\\n # {'name': ('example.png', \\n # <_io.BufferedReader name=\\\"./example.png\\\">,\\n # 'image/png')}\\n files = {'name': (name, f, mime_type)}\\n self.log.debug(f\\\"files: {files}\\\")\\n response = self.session.post(url, files=files)\\n \\n if response.status_code != 201:\\n err = f\\\"PUT failed: {url}: {response}\\\"\\n self.log.error(err)\\n self.log.debug(f\\\"TEXT: {response.text}\\\")\\n raise APIError(response, err)\",\n \"def upload_file(self, session, output, serverdir):\\n name = output.metadata['filename']\\n self.log.debug(\\\"uploading %r to %r as %r\\\",\\n output.file.name, serverdir, name)\\n\\n kwargs = {}\\n if self.blocksize is not None:\\n kwargs['blocksize'] = self.blocksize\\n self.log.debug(\\\"using blocksize %d\\\", self.blocksize)\\n\\n upload_logger = KojiUploadLogger(self.log)\\n session.uploadWrapper(output.file.name, serverdir, name=name,\\n callback=upload_logger.callback, **kwargs)\\n path = os.path.join(serverdir, name)\\n self.log.debug(\\\"uploaded %r\\\", path)\\n return path\",\n \"def upload(self,filename,remotefolder=None):\\n\\n if remotefolder == None:\\n remotefolder = self.remotefolder\\n\\n self.status = 0\\n\\n try:\\n self.ftp.cwd(remotefolder)\\n\\n self.file = open(filename, 'rb')\\n\\n (head, tail) = os.path.split(filename)\\n\\n command = \\\"STOR \\\" + tail\\n\\n print('Uploading: ' + tail)\\n self.ftp.storbinary(command, self.file)\\n print('Upload Completed')\\n\\n except ftplib.all_errors:\\n print('Error Uploading ' + tail)\\n self.status = 1\\n return self.status\\n\\n self.file.close()\\n\\n #back to initial directory in __init__()\\n self.ftp.cwd(self.remotefolder)\\n\\n return self.status\",\n \"def upload_file():\\r\\n if not LOGGEDIN:\\r\\n return render_template(\\\"login_temp.html\\\", msg=\\\"\\\")\\r\\n\\r\\n if request.method == 'POST':\\r\\n firstname = flask.request.form[\\\"firstname\\\"]\\r\\n lastname = flask.request.form[\\\"lastname\\\"]\\r\\n city = flask.request.form[\\\"city\\\"]\\r\\n state = flask.request.form[\\\"state\\\"]\\r\\n status = flask.request.form[\\\"status\\\"]\\r\\n date = flask.request.form[\\\"date\\\"]\\r\\n photo = flask.request.form[\\\"photo\\\"]\\r\\n\\r\\n f_d = open(\\\"users/\\\" + lastname + firstname + \\\".txt\\\", \\\"a\\\")\\r\\n f_d.write(firstname + \\\"\\\\n\\\")\\r\\n f_d.write(lastname + \\\"\\\\n\\\")\\r\\n f_d.write(city + \\\"\\\\n\\\")\\r\\n f_d.write(state + \\\"\\\\n\\\")\\r\\n f_d.write(status + \\\"\\\\n\\\")\\r\\n f_d.write(date + \\\"\\\\n\\\")\\r\\n f_d.write(photo + \\\"\\\\n\\\")\\r\\n f_d.close()\\r\\n return render_template(\\\"home.html\\\")\\r\\n else:\\r\\n return render_template('check_in.html')\",\n \"def post(file: str, data: bytes, addr: tuple):\\n assert (\\n type(file) == str or type(addr) == tuple or type(data) == bytes\\n ), \\\"Invalid Parameter Types\\\"\\n request = pickle.dumps([\\\"post\\\", file])\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n s.connect(addr)\\n s.sendall(request)\\n s.recv(1)\\n data = bdtp.new_send_data_port(data, (\\\"\\\", 0))\\n data.send(s)\\n s.close()\",\n \"def upload_file(self):\\n request = copy.deepcopy(self.request_template)\\n data = json.dumps(request)\\n curr_file = {\\n 'request': data,\\n 'file': open(self.file_path, 'rb')\\n }\\n print(\\\"Sending Upload request of av for file {}\\\".format(self.file_name))\\n try:\\n response = requests.post(url=self.url + \\\"upload\\\", files=curr_file, verify=False)\\n except Exception as E:\\n print(\\\"Upload file failed. file: {} , failure: {}\\\".format(self.file_name, E))\\n raise\\n response_j = response.json()\\n print(\\\"av Upload response status for file {} : {}\\\".format(self.file_name,\\n response_j[\\\"response\\\"][0][\\\"status\\\"][\\\"label\\\"]))\\n return response_j\",\n \"def upload(request):\\n if request.method != \\\"POST\\\":\\n return probe(request)\\n\\n md5chunk = request.args.get('md5chunk', False)\\n md5total = request.args.get('md5total', False)\\n\\n chunk = int(request.args.get('chunk', 0))\\n chunks = int(request.args.get('chunks', 0))\\n\\n if md5chunk and md5total:\\n filename = upload_with_checksum(request, md5chunk, md5total, chunk, chunks)\\n else:\\n filename = upload_simple(request, chunk)\\n\\n return Response('%s uploaded' % filename)\",\n \"def do_upload(ftp):\\n # Active (PORT), Passive (PASV), ExtActive (EPRT), or ExtPassive (EPSV)?\\n output, sock, transfer_type = get_transfer_output_and_socket(ftp)\\n print_debug(output + \\\"\\\\n\\\")\\n\\n # What file to upload?\\n local_file = raw_input(\\\"What local file do you want to upload?\\\\n> \\\")\\n is_file = os.path.isfile(local_file)\\n while not local_file or not is_file:\\n if not is_file:\\n print(\\\"File not found.\\\")\\n local_file = raw_input(\\\"What local file do you want to upload?\\\\n> \\\")\\n is_file = os.path.isfile(local_file)\\n # What to save file as?\\n remote_path = raw_input(\\\"What do you want to name the remote file?\\\\n> \\\")\\n while not remote_path:\\n remote_path = raw_input(\\\"What do you want to name the remote file?\\\\n> \\\")\\n try:\\n msg_rec, data_rec = ftp.stor_cmd(sock, local_file, remote_path, transfer_type)\\n print_debug(str(data_rec))\\n except Exception as e:\\n print(\\\"An error has occurred: \\\" + str(e) + \\\"\\\\nPlease try again.\\\")\\n return main_menu(ftp)\\n main_menu(ftp)\",\n \"def put(host, username, localpath, remotepath=None, port=22):\\n log = logging.getLogger('device.remotecall')\\n log.info('sending file from local:%s -> %s', localpath, remotepath)\\n if not remotepath:\\n remotepath = os.path.split(localpath)[1]\\n cmd = 'scp -P %s %s %s@%s:%s' % (port, localpath, username, host, remotepath)\\n try:\\n null = open('/dev/null', 'w')\\n subprocess.call(shlex.split(cmd), stdin=subprocess.PIPE, stdout=null, stderr=null)\\n null.close()\\n except Exception as e:\\n log.debug('Could not send %s file to %s: Error %s', localpath, host, e)\",\n \"def UploadFile(filename, file_id, content, is_binary, status, is_base):\\r\\n file_too_large = False\\r\\n if is_base:\\r\\n type = \\\"base\\\"\\r\\n else:\\r\\n type = \\\"current\\\"\\r\\n if len(content) > MAX_UPLOAD_SIZE:\\r\\n print (\\\"Not uploading the %s file for %s because it's too large.\\\" %\\r\\n (type, filename))\\r\\n file_too_large = True\\r\\n content = \\\"\\\"\\r\\n checksum = md5(content).hexdigest()\\r\\n if options.verbose > 0 and not file_too_large:\\r\\n print \\\"Uploading %s file for %s\\\" % (type, filename)\\r\\n url = \\\"/%d/upload_content/%d/%d\\\" % (int(issue), int(patchset), file_id)\\r\\n form_fields = [(\\\"filename\\\", filename),\\r\\n (\\\"status\\\", status),\\r\\n (\\\"checksum\\\", checksum),\\r\\n (\\\"is_binary\\\", str(is_binary)),\\r\\n (\\\"is_current\\\", str(not is_base)),\\r\\n ]\\r\\n if file_too_large:\\r\\n form_fields.append((\\\"file_too_large\\\", \\\"1\\\"))\\r\\n if options.email:\\r\\n form_fields.append((\\\"user\\\", options.email))\\r\\n ctype, body = EncodeMultipartFormData(form_fields,\\r\\n [(\\\"data\\\", filename, content)])\\r\\n response_body = rpc_server.Send(url, body,\\r\\n content_type=ctype)\\r\\n if not response_body.startswith(\\\"OK\\\"):\\r\\n StatusUpdate(\\\" --> %s\\\" % response_body)\\r\\n sys.exit(1)\",\n \"def upload(self, host, node, local, remote=\\\"\\\"):\\n cmd = [\\\"scp\\\", local, host + \\\":\\\" + remote]\\n if os.path.isdir(local):\\n cmd.insert(1, \\\"-r\\\")\\n pipe = self._issuecommand(cmd)\\n return self._waitforall([pipe]) == 0\",\n \"def upload_local_file_to_oh(file_path, file_name, file_metadata, access_token, member_id):\\r\\n try:\\r\\n with open(file_path, 'rb') as fs:\\r\\n upload_stream(fs, file_name, file_metadata, access_token)\\r\\n return True\\r\\n except:\\r\\n print(f'Failed to upload {file_path} to OH for OH member {member_id}')\\r\\n return False\"\n]"},"negative_scores":{"kind":"list like","value":["0.68752784","0.672209","0.6701313","0.66228","0.6602018","0.6584897","0.6579177","0.65558815","0.6509413","0.65081227","0.64988804","0.6480952","0.6429412","0.64271265","0.6385441","0.6369564","0.63390976","0.63218266","0.6314229","0.63084084","0.6304595","0.6253425","0.62463784","0.6236206","0.62192416","0.62155473","0.6210443","0.6209265","0.6194807","0.6185606","0.61735946","0.6172074","0.6168351","0.616671","0.6156829","0.6151325","0.61441356","0.6142351","0.6140808","0.61259633","0.61100036","0.6109251","0.6098339","0.6095151","0.60935247","0.60896504","0.6082085","0.6079379","0.6073774","0.60733616","0.6071767","0.60689914","0.6049927","0.6031234","0.60153174","0.6008854","0.6001867","0.5996366","0.5993383","0.5988827","0.5983681","0.597251","0.59645176","0.5963535","0.5945195","0.5940251","0.59353113","0.59342927","0.5930132","0.59257764","0.5923906","0.59182084","0.5900737","0.5892371","0.58839446","0.5879591","0.5866682","0.5863279","0.58622503","0.5861934","0.58619195","0.5854975","0.58539295","0.5850481","0.582908","0.582782","0.5824364","0.5823813","0.5816019","0.58148193","0.5794954","0.5793965","0.5791378","0.5788218","0.57858175","0.5778385","0.5770659","0.5759371","0.57581335","0.57543427"],"string":"[\n \"0.68752784\",\n \"0.672209\",\n \"0.6701313\",\n \"0.66228\",\n \"0.6602018\",\n \"0.6584897\",\n \"0.6579177\",\n \"0.65558815\",\n \"0.6509413\",\n \"0.65081227\",\n \"0.64988804\",\n \"0.6480952\",\n \"0.6429412\",\n \"0.64271265\",\n \"0.6385441\",\n \"0.6369564\",\n \"0.63390976\",\n \"0.63218266\",\n \"0.6314229\",\n \"0.63084084\",\n \"0.6304595\",\n \"0.6253425\",\n \"0.62463784\",\n \"0.6236206\",\n \"0.62192416\",\n \"0.62155473\",\n \"0.6210443\",\n \"0.6209265\",\n \"0.6194807\",\n \"0.6185606\",\n \"0.61735946\",\n \"0.6172074\",\n \"0.6168351\",\n \"0.616671\",\n \"0.6156829\",\n \"0.6151325\",\n \"0.61441356\",\n \"0.6142351\",\n \"0.6140808\",\n \"0.61259633\",\n \"0.61100036\",\n \"0.6109251\",\n \"0.6098339\",\n \"0.6095151\",\n \"0.60935247\",\n \"0.60896504\",\n \"0.6082085\",\n \"0.6079379\",\n \"0.6073774\",\n \"0.60733616\",\n \"0.6071767\",\n \"0.60689914\",\n \"0.6049927\",\n \"0.6031234\",\n \"0.60153174\",\n \"0.6008854\",\n \"0.6001867\",\n \"0.5996366\",\n \"0.5993383\",\n \"0.5988827\",\n \"0.5983681\",\n \"0.597251\",\n \"0.59645176\",\n \"0.5963535\",\n \"0.5945195\",\n \"0.5940251\",\n \"0.59353113\",\n \"0.59342927\",\n \"0.5930132\",\n \"0.59257764\",\n \"0.5923906\",\n \"0.59182084\",\n \"0.5900737\",\n \"0.5892371\",\n \"0.58839446\",\n \"0.5879591\",\n \"0.5866682\",\n \"0.5863279\",\n \"0.58622503\",\n \"0.5861934\",\n \"0.58619195\",\n \"0.5854975\",\n \"0.58539295\",\n \"0.5850481\",\n \"0.582908\",\n \"0.582782\",\n \"0.5824364\",\n \"0.5823813\",\n \"0.5816019\",\n \"0.58148193\",\n \"0.5794954\",\n \"0.5793965\",\n \"0.5791378\",\n \"0.5788218\",\n \"0.57858175\",\n \"0.5778385\",\n \"0.5770659\",\n \"0.5759371\",\n \"0.57581335\",\n \"0.57543427\"\n]"},"document_score":{"kind":"string","value":"0.577518"},"document_rank":{"kind":"string","value":"96"}}},{"rowIdx":1687,"cells":{"query":{"kind":"string","value":"POST handler that downloads file from remote host."},"document":{"kind":"string","value":"async def DownloadFromRemoteNodeHandler(request):\n fileSize = 0\n timestampStart = datetime.utcnow()\n usedHandler = 'downloadFileFromRemoteNode'\n try:\n data = await request.post()\n try:\n testId = data['testId']\n except Exception as e:\n print('no testId, generating own')\n testId = str(uuid.uuid4())\n try:\n fileName = data['destinationFileName']\n except Exception as e:\n print('no fileName, generating own')\n fileName = \"\".join(choice(allchar) for x in range(randint(5, 5)))\n try:\n sourceHost = data['sourceHost']\n sourceFileName = data['sourceFileName']\n except Exception as e:\n print('no sourceHost and sourceFileName')\n\n fileUrl = 'http://'+sourceHost+'/downloadFile/'+sourceFileName+'/'+testId\n\n async with ClientSession() as session:\n try:\n async with session.get(fileUrl) as response:\n async for data in response.content.iter_chunked(1024):\n fileSize += len(data)\n timestampEnd = datetime.utcnow()\n taskDuration = str(timestampEnd - timestampStart)\n testResults.setdefault(testId, {}).setdefault(usedHandler, {})[\"fileName\"] = fileName\n testResults.setdefault(testId, {}).setdefault(usedHandler, {})[\"sourceFileName\"] = sourceFileName\n testResults.setdefault(testId, {}).setdefault(usedHandler, {})[\"fileSize\"] = fileSize\n testResults.setdefault(testId, {}).setdefault(usedHandler, {})[\"timestampStart\"] = str(timestampStart)\n testResults.setdefault(testId, {}).setdefault(usedHandler, {})[\"timestampEnd\"] = str(timestampEnd)\n testResults.setdefault(testId, {}).setdefault(usedHandler, {})[\"taskDuration\"] = taskDuration\n response_obj = { 'status': 'success', 'message': 'File downloaded', 'testId': testId, 'usedHandler': usedHandler, 'taskDuration': taskDuration, 'fileName': fileName, 'sourceFileName': sourceFileName, 'fileSize': fileSize, 'timestampStart': str(timestampStart), 'timestampEnd': str(timestampEnd) }\n return web.json_response(response_obj)\n except Exception as e:\n response_obj = { 'status' : 'failed', 'message': str(e) }\n return web.json_response(response_obj)\n except Exception as e:\n response_obj = { 'status' : 'failed', 'message': str(e) }\n return web.json_response(response_obj)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def download_file(self, remote_file):\n remote_file.download()","def download_file():\n\n if 'POST' == request.method:\n file_id = request.form['file_id']\n else:\n file_id = request.args.get('file_id')\n\n # 1 ==> example_1.tgz\n file_path = file_manager.get_file_path_from_id(file_id)\n print \"serving file: \" + file_path\n return send_file(file_path, as_attachment=True)","def post_download(self, remote_files):\n pass","def downloadFile(remote_path, fobj):\n logger.msg(\n \"downloading file\", remote_path=remote_path, function='downloadFile'\n )\n\n def file_writer(data):\n fobj.write(data)\n\n remote_path = remote_path.encode('utf-8')\n r = yield treq.get(remote_path, timeout=5)\n try:\n yield treq.collect(r, file_writer)\n except Exception as e:\n print e\n raise","def download_file(filename):\n return send_from_directory('uploads', filename, as_attachment=True)","def https_download_file(**data):\n import os\n import requests\n\n ##minimal data inputs payload\n server_url = data.get('server_url', '')\n file_name = data.get('file_name', '')\n file_path = data.get('file_path', '')\n headers = data.get('headers', '')\n ##extra data inputs payload\n ##\n ##\n\n if server_url==None:\n raise(NameError('No `server URL` specified'))\n \n if file_name==None:\n raise(NameError('No `file_name` specified'))\n\n file_url = os.path.join(server_url,file_name)\n\n if not os.path.exists(file_path):\n os.mkdir(file_path)\n\n full_name = os.path.join(file_path,file_name)\n \n if not os.path.isfile(full_name):\n r = requests.get(file_url, headers=headers)\n if not r.status_code==200: \n raise r.raise_for_status()\n open(full_name , 'wb').write(r.content)\n\n return full_name","def main(url, localfile):\n ph.download_file(url, localfile)","def download(connection, priv_key, server_pub_key):\r\n\r\n # Get the filename from the user\r\n file_name = input('What file would you like to download from the server?: ')\r\n\r\n # Tell the server to prepare to download a file\r\n connection.sendall(rsa.encrypt(b'DOWNLOAD', server_pub_key))\r\n\r\n # Send the file name to the server\r\n connection.sendall(rsa.encrypt(file_name.encode(), server_pub_key))\r\n\r\n # Attempt to download the file\r\n try:\r\n shared.download_file(connection, priv_key, file_name)\r\n\r\n # If the server can't find the file that is asked for\r\n except ValueError:\r\n print(''.join(['\\nThe file does not exist']), file=sys.stderr)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def download():\n return response.download(request, db)","def filedownload(source, destination):\n\n # Initiate the download\n urllib.request.urlretrieve(source, destination)","def download(self, url: str, dest: PathLike, force: bool = False):","def on_post(self, req, resp):\n LOGGER = logging.getLogger()\n \n resp.set_header('Content-Type', 'text/json')\n raw_json = req.stream.read().decode('utf-8')\n content = json.loads(raw_json, encoding='utf-8')\n\n try:\n files = content.get(\"files\")\n zip_name = content.get(\"name\")\n zip_file = DownloadFilesResource.compress_files(files, zip_name)\n resp.body = json.dumps({'file': zip_file})\n LOGGER.info(\"Zip created and ready to download\")\n except Exception as e:\n LOGGER.error(\"Error creating zip file\" , exc_info=True)\n raise falcon.HTTPInternalServerError(title=\"Error downloading files: \" + str(type(e)),\n description=(str(e) +\n ','.join(traceback.format_tb(e.__traceback__))))","def download_file():\n data = c.recv(BUFFER)\n \n if data == b\"terminate\":\n print(\"DOWNLOADING FAILED !!!\")\n return\n\n file = open(FILE_NAME,\"wb\")\n while True:\n if data == b\"DONE\":\n break\n \n print(\"Receiving. . . \")\n file.write(data)\n data = c.recv(BUFFER)\n \n file.close()\n print(\"Successfully received!!!\")\n \n print(\"Webpage saved as {} at {}\".format(FILE_NAME, getcwd())) \n return None","def download():\n\treturn response.download(request, db)","def download_file(self, parsed_event, input_dir_path):","def _download(self):\n self._system.download_file(\"http://curl.haxx.se/download/\" + self._tar_name)","def send_file(cobj, dest, port, fname, hash, handler):\n pass","def download_uploaded_file(url, user, dst):\n token, _ = Token.objects.get_or_create(user=user)\n parsed = urllib_parse.urlsplit(url)\n upload_uid = TatorCache().get_upload_uid_cache(parsed.path)\n cmd = ['wget',\n f'--header=Authorization: Token {token}',\n f'--header=Upload-Uid: {upload_uid}',\n '-O', f'{dst}',\n f\"{urllib_parse.urljoin('http://nginx-internal-svc', parsed.path)}\"]\n subprocess.run(cmd, check=True)","def do_POST(self):\r\n content_length = int(self.headers['Content-Length'])\r\n body = self.rfile.read(content_length)\r\n\r\n response = BytesIO()\r\n try:\r\n res = webServer.handle_post_msg(body)\r\n print(res)\r\n self.send_response(200)\r\n except Exception as e:\r\n print(e)\r\n res = str(e)\r\n self.send_response(500)\r\n self.end_headers()\r\n response.write(res.encode())\r\n self.wfile.write(response.getvalue())","def download(self, method, url, downloader, *args, **kwargs):\n if method.startswith('URL'):\n return downloader.enqueue_file(url, filename=partial(self.mk_filename, *args))\n\n raise NoData","def download(self, url, destination):\n fileDownloader = utils.HttpFileDownloader(url, destination)\n fileDownloader.download()","def do_POST(self):\n self.send_response(httplib.OK)\n self.send_header('Content-Type', 'application/octet-stream')\n self.end_headers()\n\n response = remote_api_pb.Response()\n try:\n request = remote_api_pb.Request()\n\n\n\n request.ParseFromString(\n self.rfile.read(int(self.headers['content-length'])))\n api_response = _ExecuteRequest(request).Encode()\n response.set_response(api_response)\n except Exception, e:\n logging.debug('Exception while handling %s\\n%s',\n request,\n traceback.format_exc())\n response.set_exception(pickle.dumps(e))\n if isinstance(e, apiproxy_errors.ApplicationError):\n application_error = response.mutable_application_error()\n application_error.set_code(e.application_error)\n application_error.set_detail(e.error_detail)\n self.wfile.write(response.Encode())","def download(self, download_path):\n return","def download_with_callback(self, url, path=None, filename=None, headers=None, force=False, func=None):","def download_file(cls, uri, fobj):\n msg = \"Backend doesn't implement download_file()\"\n raise NotImplementedError(msg)","def downloadFile(self, base_url, file_name):\n url = os.path.join(base_url, file_name)\n req = urllib2.Request(url)\n try:\n f = urllib2.urlopen(req, timeout=self.timeout)\n local_file = open(os.path.join(self.config.get('PATHS', 'pdfdir'), file_name), \"w\")\n local_file.write(f.read())\n local_file.close()\n except Exception, err:\n print \"[ Failed ]\"\n print \"\\n***ERROR in downloadFile: %s\" % err\n sys.exit(0)","def download (httpfile, path_unzip = None, outfile = None) :\n if path_unzip is None : path_unzip = GetPath ()\n file = _check_source (httpfile, path_unzip = path_unzip, outfile = outfile)\n return file","def do_GET(self):\n self.send_response(200)\n self.send_header(\"Content-type\", self.mimetype)\n self.end_headers()\n\n with open(filename, \"rb\") as file_:\n self.wfile.write(file_.read())\n file_.close()","def download(path):\n return send_from_directory(UPLOAD_DIRECTORY, path, as_attachment=True)","def download(path):\n return send_from_directory(UPLOAD_DIRECTORY, path, as_attachment=True)","def __getFile_httplib(self, _src, _dst):\n\n #-------------------- \n # Pre-download callbacks\n #-------------------- \n self.runEventCallbacks('downloadStarted', _src, -1)\n self.runEventCallbacks('downloading', _src, 0)\n\n\n\n #-------------------- \n # Download\n #-------------------- \n response = self.__httpsRequest('GET', _src)\n data = response.read() \n with open(_dst, 'wb') as f:\n f.write(data) \n\n\n\n #-------------------- \n # Post-download callbacks\n #-------------------- \n self.removeFromDownloadQueue(_src)\n self.runEventCallbacks('downloadFinished', _src)","def _get(self, remote_filename, local_path):\n\n with local_path.open('wb') as local_file:\n file_id = self.get_file_id(remote_filename)\n if file_id is None:\n raise BackendException(\n 'File \"%s\" cannot be downloaded: it does not exist' %\n remote_filename)\n\n response = self.http_client.get(\n self.content_url + '/nodes/' + file_id + '/content', stream=True)\n response.raise_for_status()\n for chunk in response.iter_content(chunk_size=DEFAULT_BUFFER_SIZE):\n if chunk:\n local_file.write(chunk)\n local_file.flush()","def _download_file(self, report_date):\n fdate = report_date.strftime('%Y-%m-%d')\n ddate = '/'.join(fdate.split('-')[:-1])\n link = FILE_URL % (ddate, fdate)\n name = os.path.basename(urlparse(link).path)\n \n try:\n print ' Accessing %s.' % name\n r = requests.get(link, stream=True)\n r.raise_for_status()\n except RequestException as e:\n status = r.status_code\n \n if status == 404:\n pass\n if status >= 500:\n print ' - Unable to download %s: %s\\n' % (name, e)\n self.failed += 1\n else:\n print ' - Downloading %s.' % name\n fpath = os.path.join(self.path, name)\n \n with open(fpath, 'wb') as f:\n for chunk in r.iter_content(1024):\n f.write(chunk)\n \n self.counts += 1\n print ' - Saved %s.' % name","def download(filename):\n print \"Downloading\", filename\n file_content = urlopen(\n urljoin(URL_PATH, filename)\n )\n write_data_to_file(\n file_content.read(),\n os.path.join(\n '/tmp',\n filename\n )\n )","def download(handle):\n storage = get_storage()\n # FIXME: 404 if not found or invalid?\n return storage.route(handle)","def _download(self, url, rel_path):\n \n tmp_dir = \"TMP_DIR=`mktemp -d`;\"\n wget_cmd = [ tmp_dir, \"wget\", \"-nv\", \"-O\", \"$TMP_DIR/archive.tgz\", url, \";\" ]\n wget_cmd = ' '.join(wget_cmd)\n \n mkdir_cmd = \"mkdir -p %s ;\" % (\"./remote_resources/\" + rel_path)\n \n cleandir_cmd = \"rm -Rf %s/* ;\" % (\"./remote_resources/\" + rel_path)\n \n untar_cmd = [ \"tar\", \"xf\", \"$TMP_DIR/archive.tgz\", \"-C\", \"./remote_resources/%s\" % rel_path, \";\" ]\n untar_cmd = ' '.join(untar_cmd)\n \n remove_cmd = \"rm -Rf $TMP_DIR;\"\n \n return self._ssh(' '.join([ wget_cmd, mkdir_cmd, cleandir_cmd, untar_cmd, remove_cmd ]))","def http_download(url, target_path):\n try:\n resp = urllib2.urlopen(url)\n except urllib2.URLError, e:\n if not hasattr(e, 'code'):\n raise\n resp = e\n if resp.code != 200:\n raise IOError(\"Request url(%s) expect 200 but got %d\" %(url, resp.code))\n\n with open(target_path, 'wb') as f:\n shutil.copyfileobj(resp, f)\n return target_path","def remote(self, requests, file, remoteHost):\n # Set the source and dest paths\n remote_url = self.base_url + '/remote?file=' + file + \"&host=\" + remoteHost\n\n print(\"Making remote request: \" + remote_url)\n\n r = requests.get(remote_url, max_price=10)\n\n print(\"Remote request completed.\")\n\n return r.json()","def download_file(self, url, path):\n print('\\tDownloading: ', path)\n with open(path, 'w') as outfile:\n try:\n response = self._http_client.get(url)\n outfile.write(response.text)\n finally:\n response.close()\n outfile.close()\n gc.collect()","def serve_download(conn, ssn_key, file_name, client_name):\n # read file contents\n file_path = \"{}/{}\".format(client_name, file_name)\n contents = None\n with open(file_path, \"r\") as fileStream:\n buffer = fileStream.read()\n contents = [buffer[0+i:16+i] for i in range(0, len(buffer), 16)]\n # get signal to begin download\n request = aes.decrypt(ssn_key, conn.recv(1024))\n if request != SIG_START:\n conn.sendall(aes.encrypt(ssn_key, SIG_BAD))\n return print(\"Bob: something went wrong with file transfer\")\n print(\"Bob: beginning transfer for {}...\".format(file_name))\n # upload file contents to client\n for i, content in enumerate(contents):\n response = aes.encrypt(ssn_key, content)\n conn.sendall(response)\n if aes.decrypt(ssn_key, conn.recv(1024)) != SIG_GOOD:\n return print(\"Bob: something went wrong with file transfer, exiting...\")\n print(\"Bob: transferring file... ({}/{})\".format(i+1, len(contents)))\n # send signal that transfer is complete\n request = aes.encrypt(ssn_key, SIG_END)\n conn.sendall(request)\n if aes.decrypt(ssn_key, conn.recv(1024)) != SIG_GOOD:\n return print(\"Bob: something went wrong with file transfer, exiting...\")\n print(\"Bob: successful upload for {}\".format(file_name))","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download():\n return response.download(request,db)","def download_file(self, net_id, request_id, file_name):\n current_user_roles = get_user_roles()\n if current_user_roles[\"STFADM\"] or net_id == current_user.net_id:\n try:\n return send_from_directory(\"{0}/user_uploads/{1}/{2}/\".format(self.__APP_PATH__, net_id, request_id),\n \"{0}\".format(secure_filename(file_name)), mimetype=\"blob\")\n except Exception as e:\n print(e)\n return abort(404)\n return abort(403)","def downloadFile(self, path, out):\n\t\ttry:\n\t\t\tlogger.info(\"downloadFile('%s', ...)\" % (path))\n\n\t\t\t# Downloads from dropbox\n\t\t\t# Manually :( update the metadata cache\n\t\t\tf, metadata = self.client.get_file_and_metadata(path)\n\t\t\tf = f.read()\n\t\t\tlogger.info('* file downloaded')\n\t\t\tself.cache_metadata.setNewValue(path, metadata)\n\t\t\tlogger.info('* metadata updated')\n\t\t\t# Write to tmp file and close\n\t\t\tos.write(out, f)\n\t\t\tlogger.info(\"* file written\")\n\t\t\tos.close(out)\n\t\t\tlogger.info('* file closed')\n\t\t\n\t\t\treturn True\n\t\texcept Exception, e:\n\t\t\tlogger.error(\"Exception %s at downloadFile(%s)\" % (sys.exc_info()[0], path))\n\t\t\tlogger.debug(pformat(sys.exc_info()))\n\t\t\treturn False","def download(self, path, rev=None, **kwargs):\n return self.get('fileops/download_file', api='CONTENT', params={\n 'root': self.root,\n 'path': path,\n 'rev': rev,\n }, stream=True, timeout=kwargs.get('timeout', 1.5), **kwargs)","def send(self, request, **kwargs):\n\n # Check that the method makes sense. Only support GET\n if request.method not in (\"GET\", \"HEAD\"):\n raise ValueError(f\"Invalid request method {request.method}\")\n\n # Parse the URL\n url_parts = urlparse(request.url)\n\n # Make the Windows URLs slightly nicer\n if is_win32 and url_parts.netloc.endswith(\":\"):\n url_parts = url_parts._replace(path=f\"/{url_parts.netloc}{url_parts.path}\", netloc=\"\")\n\n # Reject URLs with a hostname component\n if url_parts.netloc and url_parts.netloc not in (\"localhost\", \".\", \"..\", \"-\"):\n raise ValueError(\"file: URLs with hostname components are not permitted\")\n\n # If the path is relative update it to be absolute\n if url_parts.netloc in (\".\", \"..\"):\n pwd = os.path.abspath(url_parts.netloc).replace(os.sep, \"/\") + \"/\"\n if is_win32:\n # prefix the path with a / in Windows\n pwd = f\"/{pwd}\"\n url_parts = url_parts._replace(path=urljoin(pwd, url_parts.path.lstrip(\"/\")))\n\n resp = Response()\n resp.url = request.url\n\n # Open the file, translate certain errors into HTTP responses\n # Use urllib's unquote to translate percent escapes into whatever\n # they actually need to be\n try:\n # If the netloc is - then read from stdin\n if url_parts.netloc == \"-\":\n resp.raw = sys.stdin.buffer\n # make a fake response URL, the current directory\n resp.url = \"file://\" + os.path.abspath(\".\").replace(os.sep, \"/\") + \"/\"\n else:\n # Split the path on / (the URL directory separator) and decode any\n # % escapes in the parts\n path_parts = [unquote(p) for p in url_parts.path.split('/')]\n\n # Strip out the leading empty parts created from the leading /'s\n while path_parts and not path_parts[0]:\n path_parts.pop(0)\n\n # If os.sep is in any of the parts, someone fed us some shenanigans.\n # Treat is like a missing file.\n if any(os.sep in p for p in path_parts):\n raise IOError(errno.ENOENT, os.strerror(errno.ENOENT))\n\n # Look for a drive component. If one is present, store it separately\n # so that a directory separator can correctly be added to the real\n # path, and remove any empty path parts between the drive and the path.\n # Assume that a part ending with : or | (legacy) is a drive.\n if path_parts and (path_parts[0].endswith('|') or path_parts[0].endswith(':')):\n path_drive = path_parts.pop(0)\n if path_drive.endswith('|'):\n path_drive = f\"{path_drive[:-1]}:\"\n\n while path_parts and not path_parts[0]:\n path_parts.pop(0)\n else:\n path_drive = ''\n\n # Try to put the path back together\n # Join the drive back in, and stick os.sep in front of the path to\n # make it absolute.\n path = path_drive + os.sep + os.path.join(*path_parts)\n\n # Check if the drive assumptions above were correct. If path_drive\n # is set, and os.path.splitdrive does not return a drive, it wasn't\n # reall a drive. Put the path together again treating path_drive\n # as a normal path component.\n if path_drive and not os.path.splitdrive(path):\n path = os.sep + os.path.join(path_drive, *path_parts)\n\n # Use io.open since we need to add a release_conn method, and\n # methods can't be added to file objects in python 2.\n resp.raw = io.open(path, \"rb\")\n resp.raw.release_conn = resp.raw.close\n except IOError as e:\n if e.errno == errno.EACCES:\n resp.status_code = codes.forbidden\n elif e.errno == errno.ENOENT:\n resp.status_code = codes.not_found\n else:\n resp.status_code = codes.bad_request\n\n # Wrap the error message in a file-like object\n # The error message will be localized, try to convert the string\n # representation of the exception into a byte stream\n resp_str = str(e).encode(locale.getpreferredencoding(False))\n resp.raw = BytesIO(resp_str)\n resp.headers['Content-Length'] = len(resp_str)\n\n # Add release_conn to the BytesIO object\n resp.raw.release_conn = resp.raw.close\n else:\n resp.status_code = codes.ok\n\n # If it's a regular file, set the Content-Length\n resp_stat = os.fstat(resp.raw.fileno())\n if stat.S_ISREG(resp_stat.st_mode):\n resp.headers['Content-Length'] = resp_stat.st_size\n\n return resp","def _download(item):\n\n filename = item.filename()\n filename = os.path.join(item.vdir(), filename)\n logger.info(\"Downloading '%s' to %s\" % (item.show, filename))\n\n f = open(filename, \"wb\")\n\n buf = net.tivoget(item.show.url)\n for chunk in buf:\n f.write(chunk)\n\n f.close()\n\n item.downloaded = True\n item.save()","def httpretrieve_save_file(url, filename, querydata=None, postdata=None, \\\r\n httpheaders=None, proxy=None, timeout=None):\r\n\r\n # Open the output file object and http file-like object.\r\n outfileobj = open(filename, 'w')\r\n httpobj = httpretrieve_open(url, querydata=querydata, postdata=postdata, \\\r\n httpheaders=httpheaders, proxy=proxy, timeout=timeout)\r\n\r\n # Repeatedly read from the file-like HTTP object into our file, until the\r\n # response is finished.\r\n responsechunkstr = None\r\n while responsechunkstr != '':\r\n responsechunkstr = httpobj.read(4096)\r\n outfileobj.write(responsechunkstr)\r\n\r\n outfileobj.close()\r\n httpobj.close()","def download_tmp_file(path, filename):\n try:\n _file = file(_path)\n wrapper = FileWrapper(_file)\n\n # use the same type for all files\n response = HttpResponse(wrapper, content_type='text/plain') \n response['Content-Disposition'] = \\\n 'attachment; filename=%s' % unicode(filename)\n response['Content-Length'] = os.path.getsize(_path)\n return response\n except Exception,e:\n logger.exception('could not find attached file object for id: %r', id)\n raise e","def send_data(self, fp, dest: PathLike, force: bool = False):","async def _download_remote_file(\n self,\n server_name: str,\n media_id: str,\n ) -> dict:\n\n file_id = random_string(24)\n\n file_info = FileInfo(server_name=server_name, file_id=file_id)\n\n with self.media_storage.store_into_file(file_info) as (f, fname, finish):\n request_path = \"/\".join(\n (\"/_matrix/media/r0/download\", server_name, media_id)\n )\n try:\n length, headers = await self.client.get_file(\n server_name,\n request_path,\n output_stream=f,\n max_size=self.max_upload_size,\n args={\n # tell the remote server to 404 if it doesn't\n # recognise the server_name, to make sure we don't\n # end up with a routing loop.\n \"allow_remote\": \"false\"\n },\n )\n except RequestSendFailed as e:\n logger.warning(\n \"Request failed fetching remote media %s/%s: %r\",\n server_name,\n media_id,\n e,\n )\n raise SynapseError(502, \"Failed to fetch remote media\")\n\n except HttpResponseException as e:\n logger.warning(\n \"HTTP error fetching remote media %s/%s: %s\",\n server_name,\n media_id,\n e.response,\n )\n if e.code == twisted.web.http.NOT_FOUND:\n raise e.to_synapse_error()\n raise SynapseError(502, \"Failed to fetch remote media\")\n\n except SynapseError:\n logger.warning(\n \"Failed to fetch remote media %s/%s\", server_name, media_id\n )\n raise\n except NotRetryingDestination:\n logger.warning(\"Not retrying destination %r\", server_name)\n raise SynapseError(502, \"Failed to fetch remote media\")\n except Exception:\n logger.exception(\n \"Failed to fetch remote media %s/%s\", server_name, media_id\n )\n raise SynapseError(502, \"Failed to fetch remote media\")\n\n await finish()\n\n if b\"Content-Type\" in headers:\n media_type = headers[b\"Content-Type\"][0].decode(\"ascii\")\n else:\n media_type = \"application/octet-stream\"\n upload_name = get_filename_from_headers(headers)\n time_now_ms = self.clock.time_msec()\n\n # Multiple remote media download requests can race (when using\n # multiple media repos), so this may throw a violation constraint\n # exception. If it does we'll delete the newly downloaded file from\n # disk (as we're in the ctx manager).\n #\n # However: we've already called `finish()` so we may have also\n # written to the storage providers. This is preferable to the\n # alternative where we call `finish()` *after* this, where we could\n # end up having an entry in the DB but fail to write the files to\n # the storage providers.\n await self.store.store_cached_remote_media(\n origin=server_name,\n media_id=media_id,\n media_type=media_type,\n time_now_ms=self.clock.time_msec(),\n upload_name=upload_name,\n media_length=length,\n filesystem_id=file_id,\n )\n\n logger.info(\"Stored remote media in file %r\", fname)\n\n media_info = {\n \"media_type\": media_type,\n \"media_length\": length,\n \"upload_name\": upload_name,\n \"created_ts\": time_now_ms,\n \"filesystem_id\": file_id,\n }\n\n return media_info","def download(self, localfile: str, remotefile: str, overwrite: bool = True, **kwargs):\n logf = ''\n logn = self._logcnt()\n logcodei = \"%put E3969440A681A24088859985\" + logn + \";\"\n logcodeo = \"\\nE3969440A681A24088859985\" + logn\n logcodeb = logcodeo.encode()\n\n valid = self._sb.file_info(remotefile, quiet = True)\n\n if valid is None:\n return {'Success' : False, \n 'LOG' : \"File \"+str(remotefile)+\" does not exist.\"}\n\n if valid == {}:\n return {'Success' : False, \n 'LOG' : \"File \"+str(remotefile)+\" is a directory.\"}\n\n if os.path.isdir(localfile):\n locf = localfile + os.sep + remotefile.rpartition(self._sb.hostsep)[2]\n else:\n locf = localfile\n\n try:\n fd = open(locf, 'wb')\n fd.write(b'write can fail even if open worked, as it turns out')\n fd.close()\n fd = open(locf, 'wb')\n except OSError as e:\n return {'Success' : False, \n 'LOG' : \"File \"+str(locf)+\" could not be opened or written to. Error was: \"+str(e)}\n\n code = \"filename _sp_updn '\"+remotefile+\"' recfm=F encoding=binary lrecl=4096;\"\n\n ll = self.submit(code, \"text\")\n logf = ll['LOG']\n\n self.stdin[0].send(b'tom says EOL=DNLOAD \\n')\n self.stdin[0].send(b'\\n'+logcodei.encode()+b'\\n'+b'tom says EOL='+logcodeb+b'\\n')\n\n done = False\n datar = b''\n bail = False\n\n while not done:\n while True:\n if os.name == 'nt':\n try:\n rc = self.pid.wait(0)\n self.pid = None\n self._sb.SASpid = None\n return {'Success' : False, \n 'LOG' : \"SAS process has terminated unexpectedly. RC from wait was: \"+str(rc)}\n except:\n pass\n else:\n rc = os.waitpid(self.pid, os.WNOHANG)\n if rc[1]:\n self.pid = None\n self._sb.SASpid = None\n return {'Success' : False, \n 'LOG' : \"SAS process has terminated unexpectedly. RC from wait was: \"+str(rc)}\n\n if bail:\n if datar.count(logcodeb) >= 1:\n break\n try:\n data = self.stdout[0].recv(4096)\n except (BlockingIOError):\n data = b''\n\n if len(data) > 0:\n datar += data\n if len(datar) > 8300:\n fd.write(datar[:8192])\n datar = datar[8192:]\n else:\n sleep(0.1)\n try:\n log = self.stderr[0].recv(4096).decode(self.sascfg.encoding, errors='replace')\n except (BlockingIOError):\n log = b''\n\n if len(log) > 0:\n logf += log\n if logf.count(logcodeo) >= 1:\n bail = True\n done = True\n\n fd.write(datar.rpartition(logcodeb)[0])\n fd.flush()\n fd.close()\n\n self._log += logf\n final = logf.partition(logcodei)\n z = final[0].rpartition(chr(10))\n prev = '%08d' % (self._log_cnt - 1)\n zz = z[0].rpartition(\"\\nE3969440A681A24088859985\" + prev +'\\n')\n logd = zz[2].replace(\";*\\';*\\\";*/;\", '')\n\n ll = self.submit(\"filename _sp_updn;\", 'text')\n logd += ll['LOG']\n \n return {'Success' : True, \n 'LOG' : logd}","async def download_file(\n location_id: LocationID,\n file_id: StorageFileID,\n user_id: UserID,\n link_type: LinkType = LinkType.PRESIGNED,\n):","def download_finish(self, cloud_file):","def download(path):\n\treturn send_from_directory(\"results\", path, as_attachment=True)","def download():\n raise NotImplementedError","def send_file():\n data = ARGS.data\n filename = ARGS.file\n outstream = \"POST||\" + filename + \"||\" + data\n CLIENT_SOCKET.send(outstream.encode())","def sendRequest(event, context):\n file = event\n print(f\"Processing file: {file['name']}.\")\n\n filename = file['name']\n\n url = 'http://34.123.136.112:5000'\n myobj = {'filename': filename}\n\n x = requests.post(url, data = myobj)\n\n print(x.text)","def download_files(self):","def post(self):\n\n upload_files = self.get_uploads('file')\n blob_info = upload_files[0]\n self.redirect('/?upload_info=%s' % urllib.quote(blob_info.filename))","def download_file(self, url, filename):\n r = requests.get(url, stream=True)\n r.raise_for_status()\n\n with open(filename, 'wb') as f:\n for chunk in r.iter_content():\n if chunk:\n f.write(chunk)\n f.flush()","def download(self, url, filename):\n print(\"url\", url)\n print(\"filename\", filename)\n # open in binary mode\n with open(filename, \"wb\") as file:\n # get request\n try:\n r = requests.get(url)\n if r.status_code == 404:\n raise NotFoundException(\n \"URL: \", url, \" is not working. Status code 404\")\n # write to file\n file.write(r.content)\n print(\"file downloaded\")\n except ConnectionError as ex:\n print(ex)\n except NotFoundException as ex:\n print(ex)\n except Exception as ex:\n print(ex)","def _download_http(source_uri, dest_path, version):\n\n try:\n logger.info(\"Downloading the dataset.\")\n download_file(source_uri=source_uri, dest_path=dest_path)\n except DownloadError as e:\n logger.info(\n f\"The request download from {source_uri} -> {dest_path} can't \"\n f\"be completed.\"\n )\n raise e\n expected_checksum = GroceriesReal.GROCERIES_REAL_DATASET_TABLES[\n version\n ].checksum\n try:\n validate_checksum(dest_path, expected_checksum)\n except ChecksumError as e:\n logger.info(\"Checksum mismatch. Delete the downloaded files.\")\n os.remove(dest_path)\n raise e","def download_file(url, fname):\n urllib.request.urlretrieve(url, fname)"],"string":"[\n \"def download_file(self, remote_file):\\n remote_file.download()\",\n \"def download_file():\\n\\n if 'POST' == request.method:\\n file_id = request.form['file_id']\\n else:\\n file_id = request.args.get('file_id')\\n\\n # 1 ==> example_1.tgz\\n file_path = file_manager.get_file_path_from_id(file_id)\\n print \\\"serving file: \\\" + file_path\\n return send_file(file_path, as_attachment=True)\",\n \"def post_download(self, remote_files):\\n pass\",\n \"def downloadFile(remote_path, fobj):\\n logger.msg(\\n \\\"downloading file\\\", remote_path=remote_path, function='downloadFile'\\n )\\n\\n def file_writer(data):\\n fobj.write(data)\\n\\n remote_path = remote_path.encode('utf-8')\\n r = yield treq.get(remote_path, timeout=5)\\n try:\\n yield treq.collect(r, file_writer)\\n except Exception as e:\\n print e\\n raise\",\n \"def download_file(filename):\\n return send_from_directory('uploads', filename, as_attachment=True)\",\n \"def https_download_file(**data):\\n import os\\n import requests\\n\\n ##minimal data inputs payload\\n server_url = data.get('server_url', '')\\n file_name = data.get('file_name', '')\\n file_path = data.get('file_path', '')\\n headers = data.get('headers', '')\\n ##extra data inputs payload\\n ##\\n ##\\n\\n if server_url==None:\\n raise(NameError('No `server URL` specified'))\\n \\n if file_name==None:\\n raise(NameError('No `file_name` specified'))\\n\\n file_url = os.path.join(server_url,file_name)\\n\\n if not os.path.exists(file_path):\\n os.mkdir(file_path)\\n\\n full_name = os.path.join(file_path,file_name)\\n \\n if not os.path.isfile(full_name):\\n r = requests.get(file_url, headers=headers)\\n if not r.status_code==200: \\n raise r.raise_for_status()\\n open(full_name , 'wb').write(r.content)\\n\\n return full_name\",\n \"def main(url, localfile):\\n ph.download_file(url, localfile)\",\n \"def download(connection, priv_key, server_pub_key):\\r\\n\\r\\n # Get the filename from the user\\r\\n file_name = input('What file would you like to download from the server?: ')\\r\\n\\r\\n # Tell the server to prepare to download a file\\r\\n connection.sendall(rsa.encrypt(b'DOWNLOAD', server_pub_key))\\r\\n\\r\\n # Send the file name to the server\\r\\n connection.sendall(rsa.encrypt(file_name.encode(), server_pub_key))\\r\\n\\r\\n # Attempt to download the file\\r\\n try:\\r\\n shared.download_file(connection, priv_key, file_name)\\r\\n\\r\\n # If the server can't find the file that is asked for\\r\\n except ValueError:\\r\\n print(''.join(['\\\\nThe file does not exist']), file=sys.stderr)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def download():\\n return response.download(request, db)\",\n \"def filedownload(source, destination):\\n\\n # Initiate the download\\n urllib.request.urlretrieve(source, destination)\",\n \"def download(self, url: str, dest: PathLike, force: bool = False):\",\n \"def on_post(self, req, resp):\\n LOGGER = logging.getLogger()\\n \\n resp.set_header('Content-Type', 'text/json')\\n raw_json = req.stream.read().decode('utf-8')\\n content = json.loads(raw_json, encoding='utf-8')\\n\\n try:\\n files = content.get(\\\"files\\\")\\n zip_name = content.get(\\\"name\\\")\\n zip_file = DownloadFilesResource.compress_files(files, zip_name)\\n resp.body = json.dumps({'file': zip_file})\\n LOGGER.info(\\\"Zip created and ready to download\\\")\\n except Exception as e:\\n LOGGER.error(\\\"Error creating zip file\\\" , exc_info=True)\\n raise falcon.HTTPInternalServerError(title=\\\"Error downloading files: \\\" + str(type(e)),\\n description=(str(e) +\\n ','.join(traceback.format_tb(e.__traceback__))))\",\n \"def download_file():\\n data = c.recv(BUFFER)\\n \\n if data == b\\\"terminate\\\":\\n print(\\\"DOWNLOADING FAILED !!!\\\")\\n return\\n\\n file = open(FILE_NAME,\\\"wb\\\")\\n while True:\\n if data == b\\\"DONE\\\":\\n break\\n \\n print(\\\"Receiving. . . \\\")\\n file.write(data)\\n data = c.recv(BUFFER)\\n \\n file.close()\\n print(\\\"Successfully received!!!\\\")\\n \\n print(\\\"Webpage saved as {} at {}\\\".format(FILE_NAME, getcwd())) \\n return None\",\n \"def download():\\n\\treturn response.download(request, db)\",\n \"def download_file(self, parsed_event, input_dir_path):\",\n \"def _download(self):\\n self._system.download_file(\\\"http://curl.haxx.se/download/\\\" + self._tar_name)\",\n \"def send_file(cobj, dest, port, fname, hash, handler):\\n pass\",\n \"def download_uploaded_file(url, user, dst):\\n token, _ = Token.objects.get_or_create(user=user)\\n parsed = urllib_parse.urlsplit(url)\\n upload_uid = TatorCache().get_upload_uid_cache(parsed.path)\\n cmd = ['wget',\\n f'--header=Authorization: Token {token}',\\n f'--header=Upload-Uid: {upload_uid}',\\n '-O', f'{dst}',\\n f\\\"{urllib_parse.urljoin('http://nginx-internal-svc', parsed.path)}\\\"]\\n subprocess.run(cmd, check=True)\",\n \"def do_POST(self):\\r\\n content_length = int(self.headers['Content-Length'])\\r\\n body = self.rfile.read(content_length)\\r\\n\\r\\n response = BytesIO()\\r\\n try:\\r\\n res = webServer.handle_post_msg(body)\\r\\n print(res)\\r\\n self.send_response(200)\\r\\n except Exception as e:\\r\\n print(e)\\r\\n res = str(e)\\r\\n self.send_response(500)\\r\\n self.end_headers()\\r\\n response.write(res.encode())\\r\\n self.wfile.write(response.getvalue())\",\n \"def download(self, method, url, downloader, *args, **kwargs):\\n if method.startswith('URL'):\\n return downloader.enqueue_file(url, filename=partial(self.mk_filename, *args))\\n\\n raise NoData\",\n \"def download(self, url, destination):\\n fileDownloader = utils.HttpFileDownloader(url, destination)\\n fileDownloader.download()\",\n \"def do_POST(self):\\n self.send_response(httplib.OK)\\n self.send_header('Content-Type', 'application/octet-stream')\\n self.end_headers()\\n\\n response = remote_api_pb.Response()\\n try:\\n request = remote_api_pb.Request()\\n\\n\\n\\n request.ParseFromString(\\n self.rfile.read(int(self.headers['content-length'])))\\n api_response = _ExecuteRequest(request).Encode()\\n response.set_response(api_response)\\n except Exception, e:\\n logging.debug('Exception while handling %s\\\\n%s',\\n request,\\n traceback.format_exc())\\n response.set_exception(pickle.dumps(e))\\n if isinstance(e, apiproxy_errors.ApplicationError):\\n application_error = response.mutable_application_error()\\n application_error.set_code(e.application_error)\\n application_error.set_detail(e.error_detail)\\n self.wfile.write(response.Encode())\",\n \"def download(self, download_path):\\n return\",\n \"def download_with_callback(self, url, path=None, filename=None, headers=None, force=False, func=None):\",\n \"def download_file(cls, uri, fobj):\\n msg = \\\"Backend doesn't implement download_file()\\\"\\n raise NotImplementedError(msg)\",\n \"def downloadFile(self, base_url, file_name):\\n url = os.path.join(base_url, file_name)\\n req = urllib2.Request(url)\\n try:\\n f = urllib2.urlopen(req, timeout=self.timeout)\\n local_file = open(os.path.join(self.config.get('PATHS', 'pdfdir'), file_name), \\\"w\\\")\\n local_file.write(f.read())\\n local_file.close()\\n except Exception, err:\\n print \\\"[ Failed ]\\\"\\n print \\\"\\\\n***ERROR in downloadFile: %s\\\" % err\\n sys.exit(0)\",\n \"def download (httpfile, path_unzip = None, outfile = None) :\\n if path_unzip is None : path_unzip = GetPath ()\\n file = _check_source (httpfile, path_unzip = path_unzip, outfile = outfile)\\n return file\",\n \"def do_GET(self):\\n self.send_response(200)\\n self.send_header(\\\"Content-type\\\", self.mimetype)\\n self.end_headers()\\n\\n with open(filename, \\\"rb\\\") as file_:\\n self.wfile.write(file_.read())\\n file_.close()\",\n \"def download(path):\\n return send_from_directory(UPLOAD_DIRECTORY, path, as_attachment=True)\",\n \"def download(path):\\n return send_from_directory(UPLOAD_DIRECTORY, path, as_attachment=True)\",\n \"def __getFile_httplib(self, _src, _dst):\\n\\n #-------------------- \\n # Pre-download callbacks\\n #-------------------- \\n self.runEventCallbacks('downloadStarted', _src, -1)\\n self.runEventCallbacks('downloading', _src, 0)\\n\\n\\n\\n #-------------------- \\n # Download\\n #-------------------- \\n response = self.__httpsRequest('GET', _src)\\n data = response.read() \\n with open(_dst, 'wb') as f:\\n f.write(data) \\n\\n\\n\\n #-------------------- \\n # Post-download callbacks\\n #-------------------- \\n self.removeFromDownloadQueue(_src)\\n self.runEventCallbacks('downloadFinished', _src)\",\n \"def _get(self, remote_filename, local_path):\\n\\n with local_path.open('wb') as local_file:\\n file_id = self.get_file_id(remote_filename)\\n if file_id is None:\\n raise BackendException(\\n 'File \\\"%s\\\" cannot be downloaded: it does not exist' %\\n remote_filename)\\n\\n response = self.http_client.get(\\n self.content_url + '/nodes/' + file_id + '/content', stream=True)\\n response.raise_for_status()\\n for chunk in response.iter_content(chunk_size=DEFAULT_BUFFER_SIZE):\\n if chunk:\\n local_file.write(chunk)\\n local_file.flush()\",\n \"def _download_file(self, report_date):\\n fdate = report_date.strftime('%Y-%m-%d')\\n ddate = '/'.join(fdate.split('-')[:-1])\\n link = FILE_URL % (ddate, fdate)\\n name = os.path.basename(urlparse(link).path)\\n \\n try:\\n print ' Accessing %s.' % name\\n r = requests.get(link, stream=True)\\n r.raise_for_status()\\n except RequestException as e:\\n status = r.status_code\\n \\n if status == 404:\\n pass\\n if status >= 500:\\n print ' - Unable to download %s: %s\\\\n' % (name, e)\\n self.failed += 1\\n else:\\n print ' - Downloading %s.' % name\\n fpath = os.path.join(self.path, name)\\n \\n with open(fpath, 'wb') as f:\\n for chunk in r.iter_content(1024):\\n f.write(chunk)\\n \\n self.counts += 1\\n print ' - Saved %s.' % name\",\n \"def download(filename):\\n print \\\"Downloading\\\", filename\\n file_content = urlopen(\\n urljoin(URL_PATH, filename)\\n )\\n write_data_to_file(\\n file_content.read(),\\n os.path.join(\\n '/tmp',\\n filename\\n )\\n )\",\n \"def download(handle):\\n storage = get_storage()\\n # FIXME: 404 if not found or invalid?\\n return storage.route(handle)\",\n \"def _download(self, url, rel_path):\\n \\n tmp_dir = \\\"TMP_DIR=`mktemp -d`;\\\"\\n wget_cmd = [ tmp_dir, \\\"wget\\\", \\\"-nv\\\", \\\"-O\\\", \\\"$TMP_DIR/archive.tgz\\\", url, \\\";\\\" ]\\n wget_cmd = ' '.join(wget_cmd)\\n \\n mkdir_cmd = \\\"mkdir -p %s ;\\\" % (\\\"./remote_resources/\\\" + rel_path)\\n \\n cleandir_cmd = \\\"rm -Rf %s/* ;\\\" % (\\\"./remote_resources/\\\" + rel_path)\\n \\n untar_cmd = [ \\\"tar\\\", \\\"xf\\\", \\\"$TMP_DIR/archive.tgz\\\", \\\"-C\\\", \\\"./remote_resources/%s\\\" % rel_path, \\\";\\\" ]\\n untar_cmd = ' '.join(untar_cmd)\\n \\n remove_cmd = \\\"rm -Rf $TMP_DIR;\\\"\\n \\n return self._ssh(' '.join([ wget_cmd, mkdir_cmd, cleandir_cmd, untar_cmd, remove_cmd ]))\",\n \"def http_download(url, target_path):\\n try:\\n resp = urllib2.urlopen(url)\\n except urllib2.URLError, e:\\n if not hasattr(e, 'code'):\\n raise\\n resp = e\\n if resp.code != 200:\\n raise IOError(\\\"Request url(%s) expect 200 but got %d\\\" %(url, resp.code))\\n\\n with open(target_path, 'wb') as f:\\n shutil.copyfileobj(resp, f)\\n return target_path\",\n \"def remote(self, requests, file, remoteHost):\\n # Set the source and dest paths\\n remote_url = self.base_url + '/remote?file=' + file + \\\"&host=\\\" + remoteHost\\n\\n print(\\\"Making remote request: \\\" + remote_url)\\n\\n r = requests.get(remote_url, max_price=10)\\n\\n print(\\\"Remote request completed.\\\")\\n\\n return r.json()\",\n \"def download_file(self, url, path):\\n print('\\\\tDownloading: ', path)\\n with open(path, 'w') as outfile:\\n try:\\n response = self._http_client.get(url)\\n outfile.write(response.text)\\n finally:\\n response.close()\\n outfile.close()\\n gc.collect()\",\n \"def serve_download(conn, ssn_key, file_name, client_name):\\n # read file contents\\n file_path = \\\"{}/{}\\\".format(client_name, file_name)\\n contents = None\\n with open(file_path, \\\"r\\\") as fileStream:\\n buffer = fileStream.read()\\n contents = [buffer[0+i:16+i] for i in range(0, len(buffer), 16)]\\n # get signal to begin download\\n request = aes.decrypt(ssn_key, conn.recv(1024))\\n if request != SIG_START:\\n conn.sendall(aes.encrypt(ssn_key, SIG_BAD))\\n return print(\\\"Bob: something went wrong with file transfer\\\")\\n print(\\\"Bob: beginning transfer for {}...\\\".format(file_name))\\n # upload file contents to client\\n for i, content in enumerate(contents):\\n response = aes.encrypt(ssn_key, content)\\n conn.sendall(response)\\n if aes.decrypt(ssn_key, conn.recv(1024)) != SIG_GOOD:\\n return print(\\\"Bob: something went wrong with file transfer, exiting...\\\")\\n print(\\\"Bob: transferring file... ({}/{})\\\".format(i+1, len(contents)))\\n # send signal that transfer is complete\\n request = aes.encrypt(ssn_key, SIG_END)\\n conn.sendall(request)\\n if aes.decrypt(ssn_key, conn.recv(1024)) != SIG_GOOD:\\n return print(\\\"Bob: something went wrong with file transfer, exiting...\\\")\\n print(\\\"Bob: successful upload for {}\\\".format(file_name))\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download():\\n return response.download(request,db)\",\n \"def download_file(self, net_id, request_id, file_name):\\n current_user_roles = get_user_roles()\\n if current_user_roles[\\\"STFADM\\\"] or net_id == current_user.net_id:\\n try:\\n return send_from_directory(\\\"{0}/user_uploads/{1}/{2}/\\\".format(self.__APP_PATH__, net_id, request_id),\\n \\\"{0}\\\".format(secure_filename(file_name)), mimetype=\\\"blob\\\")\\n except Exception as e:\\n print(e)\\n return abort(404)\\n return abort(403)\",\n \"def downloadFile(self, path, out):\\n\\t\\ttry:\\n\\t\\t\\tlogger.info(\\\"downloadFile('%s', ...)\\\" % (path))\\n\\n\\t\\t\\t# Downloads from dropbox\\n\\t\\t\\t# Manually :( update the metadata cache\\n\\t\\t\\tf, metadata = self.client.get_file_and_metadata(path)\\n\\t\\t\\tf = f.read()\\n\\t\\t\\tlogger.info('* file downloaded')\\n\\t\\t\\tself.cache_metadata.setNewValue(path, metadata)\\n\\t\\t\\tlogger.info('* metadata updated')\\n\\t\\t\\t# Write to tmp file and close\\n\\t\\t\\tos.write(out, f)\\n\\t\\t\\tlogger.info(\\\"* file written\\\")\\n\\t\\t\\tos.close(out)\\n\\t\\t\\tlogger.info('* file closed')\\n\\t\\t\\n\\t\\t\\treturn True\\n\\t\\texcept Exception, e:\\n\\t\\t\\tlogger.error(\\\"Exception %s at downloadFile(%s)\\\" % (sys.exc_info()[0], path))\\n\\t\\t\\tlogger.debug(pformat(sys.exc_info()))\\n\\t\\t\\treturn False\",\n \"def download(self, path, rev=None, **kwargs):\\n return self.get('fileops/download_file', api='CONTENT', params={\\n 'root': self.root,\\n 'path': path,\\n 'rev': rev,\\n }, stream=True, timeout=kwargs.get('timeout', 1.5), **kwargs)\",\n \"def send(self, request, **kwargs):\\n\\n # Check that the method makes sense. Only support GET\\n if request.method not in (\\\"GET\\\", \\\"HEAD\\\"):\\n raise ValueError(f\\\"Invalid request method {request.method}\\\")\\n\\n # Parse the URL\\n url_parts = urlparse(request.url)\\n\\n # Make the Windows URLs slightly nicer\\n if is_win32 and url_parts.netloc.endswith(\\\":\\\"):\\n url_parts = url_parts._replace(path=f\\\"/{url_parts.netloc}{url_parts.path}\\\", netloc=\\\"\\\")\\n\\n # Reject URLs with a hostname component\\n if url_parts.netloc and url_parts.netloc not in (\\\"localhost\\\", \\\".\\\", \\\"..\\\", \\\"-\\\"):\\n raise ValueError(\\\"file: URLs with hostname components are not permitted\\\")\\n\\n # If the path is relative update it to be absolute\\n if url_parts.netloc in (\\\".\\\", \\\"..\\\"):\\n pwd = os.path.abspath(url_parts.netloc).replace(os.sep, \\\"/\\\") + \\\"/\\\"\\n if is_win32:\\n # prefix the path with a / in Windows\\n pwd = f\\\"/{pwd}\\\"\\n url_parts = url_parts._replace(path=urljoin(pwd, url_parts.path.lstrip(\\\"/\\\")))\\n\\n resp = Response()\\n resp.url = request.url\\n\\n # Open the file, translate certain errors into HTTP responses\\n # Use urllib's unquote to translate percent escapes into whatever\\n # they actually need to be\\n try:\\n # If the netloc is - then read from stdin\\n if url_parts.netloc == \\\"-\\\":\\n resp.raw = sys.stdin.buffer\\n # make a fake response URL, the current directory\\n resp.url = \\\"file://\\\" + os.path.abspath(\\\".\\\").replace(os.sep, \\\"/\\\") + \\\"/\\\"\\n else:\\n # Split the path on / (the URL directory separator) and decode any\\n # % escapes in the parts\\n path_parts = [unquote(p) for p in url_parts.path.split('/')]\\n\\n # Strip out the leading empty parts created from the leading /'s\\n while path_parts and not path_parts[0]:\\n path_parts.pop(0)\\n\\n # If os.sep is in any of the parts, someone fed us some shenanigans.\\n # Treat is like a missing file.\\n if any(os.sep in p for p in path_parts):\\n raise IOError(errno.ENOENT, os.strerror(errno.ENOENT))\\n\\n # Look for a drive component. If one is present, store it separately\\n # so that a directory separator can correctly be added to the real\\n # path, and remove any empty path parts between the drive and the path.\\n # Assume that a part ending with : or | (legacy) is a drive.\\n if path_parts and (path_parts[0].endswith('|') or path_parts[0].endswith(':')):\\n path_drive = path_parts.pop(0)\\n if path_drive.endswith('|'):\\n path_drive = f\\\"{path_drive[:-1]}:\\\"\\n\\n while path_parts and not path_parts[0]:\\n path_parts.pop(0)\\n else:\\n path_drive = ''\\n\\n # Try to put the path back together\\n # Join the drive back in, and stick os.sep in front of the path to\\n # make it absolute.\\n path = path_drive + os.sep + os.path.join(*path_parts)\\n\\n # Check if the drive assumptions above were correct. If path_drive\\n # is set, and os.path.splitdrive does not return a drive, it wasn't\\n # reall a drive. Put the path together again treating path_drive\\n # as a normal path component.\\n if path_drive and not os.path.splitdrive(path):\\n path = os.sep + os.path.join(path_drive, *path_parts)\\n\\n # Use io.open since we need to add a release_conn method, and\\n # methods can't be added to file objects in python 2.\\n resp.raw = io.open(path, \\\"rb\\\")\\n resp.raw.release_conn = resp.raw.close\\n except IOError as e:\\n if e.errno == errno.EACCES:\\n resp.status_code = codes.forbidden\\n elif e.errno == errno.ENOENT:\\n resp.status_code = codes.not_found\\n else:\\n resp.status_code = codes.bad_request\\n\\n # Wrap the error message in a file-like object\\n # The error message will be localized, try to convert the string\\n # representation of the exception into a byte stream\\n resp_str = str(e).encode(locale.getpreferredencoding(False))\\n resp.raw = BytesIO(resp_str)\\n resp.headers['Content-Length'] = len(resp_str)\\n\\n # Add release_conn to the BytesIO object\\n resp.raw.release_conn = resp.raw.close\\n else:\\n resp.status_code = codes.ok\\n\\n # If it's a regular file, set the Content-Length\\n resp_stat = os.fstat(resp.raw.fileno())\\n if stat.S_ISREG(resp_stat.st_mode):\\n resp.headers['Content-Length'] = resp_stat.st_size\\n\\n return resp\",\n \"def _download(item):\\n\\n filename = item.filename()\\n filename = os.path.join(item.vdir(), filename)\\n logger.info(\\\"Downloading '%s' to %s\\\" % (item.show, filename))\\n\\n f = open(filename, \\\"wb\\\")\\n\\n buf = net.tivoget(item.show.url)\\n for chunk in buf:\\n f.write(chunk)\\n\\n f.close()\\n\\n item.downloaded = True\\n item.save()\",\n \"def httpretrieve_save_file(url, filename, querydata=None, postdata=None, \\\\\\r\\n httpheaders=None, proxy=None, timeout=None):\\r\\n\\r\\n # Open the output file object and http file-like object.\\r\\n outfileobj = open(filename, 'w')\\r\\n httpobj = httpretrieve_open(url, querydata=querydata, postdata=postdata, \\\\\\r\\n httpheaders=httpheaders, proxy=proxy, timeout=timeout)\\r\\n\\r\\n # Repeatedly read from the file-like HTTP object into our file, until the\\r\\n # response is finished.\\r\\n responsechunkstr = None\\r\\n while responsechunkstr != '':\\r\\n responsechunkstr = httpobj.read(4096)\\r\\n outfileobj.write(responsechunkstr)\\r\\n\\r\\n outfileobj.close()\\r\\n httpobj.close()\",\n \"def download_tmp_file(path, filename):\\n try:\\n _file = file(_path)\\n wrapper = FileWrapper(_file)\\n\\n # use the same type for all files\\n response = HttpResponse(wrapper, content_type='text/plain') \\n response['Content-Disposition'] = \\\\\\n 'attachment; filename=%s' % unicode(filename)\\n response['Content-Length'] = os.path.getsize(_path)\\n return response\\n except Exception,e:\\n logger.exception('could not find attached file object for id: %r', id)\\n raise e\",\n \"def send_data(self, fp, dest: PathLike, force: bool = False):\",\n \"async def _download_remote_file(\\n self,\\n server_name: str,\\n media_id: str,\\n ) -> dict:\\n\\n file_id = random_string(24)\\n\\n file_info = FileInfo(server_name=server_name, file_id=file_id)\\n\\n with self.media_storage.store_into_file(file_info) as (f, fname, finish):\\n request_path = \\\"/\\\".join(\\n (\\\"/_matrix/media/r0/download\\\", server_name, media_id)\\n )\\n try:\\n length, headers = await self.client.get_file(\\n server_name,\\n request_path,\\n output_stream=f,\\n max_size=self.max_upload_size,\\n args={\\n # tell the remote server to 404 if it doesn't\\n # recognise the server_name, to make sure we don't\\n # end up with a routing loop.\\n \\\"allow_remote\\\": \\\"false\\\"\\n },\\n )\\n except RequestSendFailed as e:\\n logger.warning(\\n \\\"Request failed fetching remote media %s/%s: %r\\\",\\n server_name,\\n media_id,\\n e,\\n )\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n\\n except HttpResponseException as e:\\n logger.warning(\\n \\\"HTTP error fetching remote media %s/%s: %s\\\",\\n server_name,\\n media_id,\\n e.response,\\n )\\n if e.code == twisted.web.http.NOT_FOUND:\\n raise e.to_synapse_error()\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n\\n except SynapseError:\\n logger.warning(\\n \\\"Failed to fetch remote media %s/%s\\\", server_name, media_id\\n )\\n raise\\n except NotRetryingDestination:\\n logger.warning(\\\"Not retrying destination %r\\\", server_name)\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n except Exception:\\n logger.exception(\\n \\\"Failed to fetch remote media %s/%s\\\", server_name, media_id\\n )\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n\\n await finish()\\n\\n if b\\\"Content-Type\\\" in headers:\\n media_type = headers[b\\\"Content-Type\\\"][0].decode(\\\"ascii\\\")\\n else:\\n media_type = \\\"application/octet-stream\\\"\\n upload_name = get_filename_from_headers(headers)\\n time_now_ms = self.clock.time_msec()\\n\\n # Multiple remote media download requests can race (when using\\n # multiple media repos), so this may throw a violation constraint\\n # exception. If it does we'll delete the newly downloaded file from\\n # disk (as we're in the ctx manager).\\n #\\n # However: we've already called `finish()` so we may have also\\n # written to the storage providers. This is preferable to the\\n # alternative where we call `finish()` *after* this, where we could\\n # end up having an entry in the DB but fail to write the files to\\n # the storage providers.\\n await self.store.store_cached_remote_media(\\n origin=server_name,\\n media_id=media_id,\\n media_type=media_type,\\n time_now_ms=self.clock.time_msec(),\\n upload_name=upload_name,\\n media_length=length,\\n filesystem_id=file_id,\\n )\\n\\n logger.info(\\\"Stored remote media in file %r\\\", fname)\\n\\n media_info = {\\n \\\"media_type\\\": media_type,\\n \\\"media_length\\\": length,\\n \\\"upload_name\\\": upload_name,\\n \\\"created_ts\\\": time_now_ms,\\n \\\"filesystem_id\\\": file_id,\\n }\\n\\n return media_info\",\n \"def download(self, localfile: str, remotefile: str, overwrite: bool = True, **kwargs):\\n logf = ''\\n logn = self._logcnt()\\n logcodei = \\\"%put E3969440A681A24088859985\\\" + logn + \\\";\\\"\\n logcodeo = \\\"\\\\nE3969440A681A24088859985\\\" + logn\\n logcodeb = logcodeo.encode()\\n\\n valid = self._sb.file_info(remotefile, quiet = True)\\n\\n if valid is None:\\n return {'Success' : False, \\n 'LOG' : \\\"File \\\"+str(remotefile)+\\\" does not exist.\\\"}\\n\\n if valid == {}:\\n return {'Success' : False, \\n 'LOG' : \\\"File \\\"+str(remotefile)+\\\" is a directory.\\\"}\\n\\n if os.path.isdir(localfile):\\n locf = localfile + os.sep + remotefile.rpartition(self._sb.hostsep)[2]\\n else:\\n locf = localfile\\n\\n try:\\n fd = open(locf, 'wb')\\n fd.write(b'write can fail even if open worked, as it turns out')\\n fd.close()\\n fd = open(locf, 'wb')\\n except OSError as e:\\n return {'Success' : False, \\n 'LOG' : \\\"File \\\"+str(locf)+\\\" could not be opened or written to. Error was: \\\"+str(e)}\\n\\n code = \\\"filename _sp_updn '\\\"+remotefile+\\\"' recfm=F encoding=binary lrecl=4096;\\\"\\n\\n ll = self.submit(code, \\\"text\\\")\\n logf = ll['LOG']\\n\\n self.stdin[0].send(b'tom says EOL=DNLOAD \\\\n')\\n self.stdin[0].send(b'\\\\n'+logcodei.encode()+b'\\\\n'+b'tom says EOL='+logcodeb+b'\\\\n')\\n\\n done = False\\n datar = b''\\n bail = False\\n\\n while not done:\\n while True:\\n if os.name == 'nt':\\n try:\\n rc = self.pid.wait(0)\\n self.pid = None\\n self._sb.SASpid = None\\n return {'Success' : False, \\n 'LOG' : \\\"SAS process has terminated unexpectedly. RC from wait was: \\\"+str(rc)}\\n except:\\n pass\\n else:\\n rc = os.waitpid(self.pid, os.WNOHANG)\\n if rc[1]:\\n self.pid = None\\n self._sb.SASpid = None\\n return {'Success' : False, \\n 'LOG' : \\\"SAS process has terminated unexpectedly. RC from wait was: \\\"+str(rc)}\\n\\n if bail:\\n if datar.count(logcodeb) >= 1:\\n break\\n try:\\n data = self.stdout[0].recv(4096)\\n except (BlockingIOError):\\n data = b''\\n\\n if len(data) > 0:\\n datar += data\\n if len(datar) > 8300:\\n fd.write(datar[:8192])\\n datar = datar[8192:]\\n else:\\n sleep(0.1)\\n try:\\n log = self.stderr[0].recv(4096).decode(self.sascfg.encoding, errors='replace')\\n except (BlockingIOError):\\n log = b''\\n\\n if len(log) > 0:\\n logf += log\\n if logf.count(logcodeo) >= 1:\\n bail = True\\n done = True\\n\\n fd.write(datar.rpartition(logcodeb)[0])\\n fd.flush()\\n fd.close()\\n\\n self._log += logf\\n final = logf.partition(logcodei)\\n z = final[0].rpartition(chr(10))\\n prev = '%08d' % (self._log_cnt - 1)\\n zz = z[0].rpartition(\\\"\\\\nE3969440A681A24088859985\\\" + prev +'\\\\n')\\n logd = zz[2].replace(\\\";*\\\\';*\\\\\\\";*/;\\\", '')\\n\\n ll = self.submit(\\\"filename _sp_updn;\\\", 'text')\\n logd += ll['LOG']\\n \\n return {'Success' : True, \\n 'LOG' : logd}\",\n \"async def download_file(\\n location_id: LocationID,\\n file_id: StorageFileID,\\n user_id: UserID,\\n link_type: LinkType = LinkType.PRESIGNED,\\n):\",\n \"def download_finish(self, cloud_file):\",\n \"def download(path):\\n\\treturn send_from_directory(\\\"results\\\", path, as_attachment=True)\",\n \"def download():\\n raise NotImplementedError\",\n \"def send_file():\\n data = ARGS.data\\n filename = ARGS.file\\n outstream = \\\"POST||\\\" + filename + \\\"||\\\" + data\\n CLIENT_SOCKET.send(outstream.encode())\",\n \"def sendRequest(event, context):\\n file = event\\n print(f\\\"Processing file: {file['name']}.\\\")\\n\\n filename = file['name']\\n\\n url = 'http://34.123.136.112:5000'\\n myobj = {'filename': filename}\\n\\n x = requests.post(url, data = myobj)\\n\\n print(x.text)\",\n \"def download_files(self):\",\n \"def post(self):\\n\\n upload_files = self.get_uploads('file')\\n blob_info = upload_files[0]\\n self.redirect('/?upload_info=%s' % urllib.quote(blob_info.filename))\",\n \"def download_file(self, url, filename):\\n r = requests.get(url, stream=True)\\n r.raise_for_status()\\n\\n with open(filename, 'wb') as f:\\n for chunk in r.iter_content():\\n if chunk:\\n f.write(chunk)\\n f.flush()\",\n \"def download(self, url, filename):\\n print(\\\"url\\\", url)\\n print(\\\"filename\\\", filename)\\n # open in binary mode\\n with open(filename, \\\"wb\\\") as file:\\n # get request\\n try:\\n r = requests.get(url)\\n if r.status_code == 404:\\n raise NotFoundException(\\n \\\"URL: \\\", url, \\\" is not working. Status code 404\\\")\\n # write to file\\n file.write(r.content)\\n print(\\\"file downloaded\\\")\\n except ConnectionError as ex:\\n print(ex)\\n except NotFoundException as ex:\\n print(ex)\\n except Exception as ex:\\n print(ex)\",\n \"def _download_http(source_uri, dest_path, version):\\n\\n try:\\n logger.info(\\\"Downloading the dataset.\\\")\\n download_file(source_uri=source_uri, dest_path=dest_path)\\n except DownloadError as e:\\n logger.info(\\n f\\\"The request download from {source_uri} -> {dest_path} can't \\\"\\n f\\\"be completed.\\\"\\n )\\n raise e\\n expected_checksum = GroceriesReal.GROCERIES_REAL_DATASET_TABLES[\\n version\\n ].checksum\\n try:\\n validate_checksum(dest_path, expected_checksum)\\n except ChecksumError as e:\\n logger.info(\\\"Checksum mismatch. Delete the downloaded files.\\\")\\n os.remove(dest_path)\\n raise e\",\n \"def download_file(url, fname):\\n urllib.request.urlretrieve(url, fname)\"\n]"},"negative_scores":{"kind":"list like","value":["0.70488554","0.7008286","0.6648603","0.65757704","0.6246295","0.61764085","0.6117598","0.611518","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.608899","0.6073451","0.60563403","0.6028612","0.60241234","0.6023703","0.6021517","0.6014625","0.6009214","0.60033023","0.5943582","0.5933319","0.59139717","0.5909919","0.59021175","0.58739036","0.5872492","0.58696324","0.5862277","0.5849184","0.5837383","0.5837383","0.583645","0.5816978","0.581659","0.5807695","0.5801353","0.58012974","0.58009017","0.58000386","0.5790061","0.5772705","0.57600737","0.57600737","0.57600737","0.57600737","0.57600737","0.57600737","0.5759733","0.5749518","0.5741315","0.57286406","0.57244796","0.5709818","0.5694729","0.5690385","0.5687368","0.5687021","0.56799716","0.56584233","0.56549895","0.56542796","0.5650565","0.5644878","0.5641255","0.56336176","0.5629423","0.56282836","0.56020933","0.5590981"],"string":"[\n \"0.70488554\",\n \"0.7008286\",\n \"0.6648603\",\n \"0.65757704\",\n \"0.6246295\",\n \"0.61764085\",\n \"0.6117598\",\n \"0.611518\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.608899\",\n \"0.6073451\",\n \"0.60563403\",\n \"0.6028612\",\n \"0.60241234\",\n \"0.6023703\",\n \"0.6021517\",\n \"0.6014625\",\n \"0.6009214\",\n \"0.60033023\",\n \"0.5943582\",\n \"0.5933319\",\n \"0.59139717\",\n \"0.5909919\",\n \"0.59021175\",\n \"0.58739036\",\n \"0.5872492\",\n \"0.58696324\",\n \"0.5862277\",\n \"0.5849184\",\n \"0.5837383\",\n \"0.5837383\",\n \"0.583645\",\n \"0.5816978\",\n \"0.581659\",\n \"0.5807695\",\n \"0.5801353\",\n \"0.58012974\",\n \"0.58009017\",\n \"0.58000386\",\n \"0.5790061\",\n \"0.5772705\",\n \"0.57600737\",\n \"0.57600737\",\n \"0.57600737\",\n \"0.57600737\",\n \"0.57600737\",\n \"0.57600737\",\n \"0.5759733\",\n \"0.5749518\",\n \"0.5741315\",\n \"0.57286406\",\n \"0.57244796\",\n \"0.5709818\",\n \"0.5694729\",\n \"0.5690385\",\n \"0.5687368\",\n \"0.5687021\",\n \"0.56799716\",\n \"0.56584233\",\n \"0.56549895\",\n \"0.56542796\",\n \"0.5650565\",\n \"0.5644878\",\n \"0.5641255\",\n \"0.56336176\",\n \"0.5629423\",\n \"0.56282836\",\n \"0.56020933\",\n \"0.5590981\"\n]"},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":1688,"cells":{"query":{"kind":"string","value":"calculates the information reduction between layers This function computes the multiinformation (total correlation) reduction after a linear transformation."},"document":{"kind":"string","value":"def information_reduction(\n X: np.ndarray, Y: np.ndarray, uni_entropy: Callable, tol_dims: int, p: float = 0.25,\n) -> float:\n # calculate the marginal entropy\n hx = jax.vmap(uni_entropy)(X.T)\n hy = jax.vmap(uni_entropy)(Y.T)\n\n # Information content\n delta_info = np.sum(hy) - np.sum(hx)\n tol_info = np.sqrt(np.sum((hy - hx) ** 2))\n\n # get tolerance\n n_dimensions = X.shape[1]\n\n # conditional\n cond = np.logical_or(\n tol_info < np.sqrt(n_dimensions * p * tol_dims ** 2), delta_info < 0\n )\n return np.array(np.where(cond, 0.0, delta_info))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def MotcorCatenate(self, info, base, anat_tgt):\n# First compute the transformation matrices due to epi-to-epi motion.\n fmt = '3dvolreg -prefix NULL -1Dmatrix_save %s -twopass ' + \\\n '-verbose -base %s+orig[%s] -dfile %s %s+orig'\n cmd = fmt % (info['matfile_m'], info['basefile'], base, \\\n info['mot_file'], info['imgfile_t'])\n self.CheckExec(cmd, [info['matfile_m']])\n\n# Catenate with transformation from epi base image to the anatomical.\n cmd = 'cat_matvec -ONELINE %s -P %s -P > %s' % \\\n (self.info[anat_tgt]['matfile'], info['matfile_m'], \\\n info['matfile_mcat'])\n self.CheckExec(cmd, [info['matfile_mcat']])\n\n# Interpolate the data to the new grid.\n fmt = '3dAllineate -prefix %s -interp cubic -1Dmatrix_apply %s ' + \\\n '-warp shift_rotate -base %s+orig[%s] %s+orig'\n cmd = fmt % (info['imgfile_m'], info['matfile_mcat'], info['basefile'], \\\n base, info['imgfile_t'])\n self.CheckExec(cmd, ['%s+orig.BRIK'%info['imgfile_m'], \\\n '%s+orig.HEAD'%info['imgfile_m']])","def main():\n feature_extraction_model = \"HOG\"\n # feature_extraction_models = [\"CM\", \"HOG\"]\n feature_extraction_model_1 = \"CM\"\n dimension_reduction_model = \"PCA\"\n k_value = 10\n dim_k_value = 40\n # K_value = 20\n # lab_folder = \"Dataset3/Labelled/Set1\"\n # unlab_folder = \"Dataset3/Unlabelled/Set 2\"\n lab_folder = get_input_folder(\"Labelled Folder\")\n unlab_folder = get_input_folder(\"Classify\")\n start = time.time()\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab = dim_red.get_object_feature_matrix()\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\n images_list_lab = np.array(obj_feat_lab['imageId'])\n # filtering the labelled set\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab = dim_red.get_object_feature_matrix()\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\n\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\n # filtering the labelled set\n\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\n\n # ================================================================================================================\n\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n features_list = np.concatenate((features_list_lab, features_list_unlab))\n images_list = np.concatenate((images_list_lab, images_list_unlab))\n images_list = list(images_list)\n # Finding Similarity Matrix\n cos_sim = cosine_similarity(features_list)\n sim_graph = np.empty((0, len(cos_sim)))\n for row in cos_sim:\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\n\n row_sums = sim_graph.sum(axis=1)\n sim_graph = sim_graph / row_sums[:, np.newaxis]\n idx = 0\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\n results_palmar = ppr(sim_graph, images_list, palmar_list)\n final_results = {}\n\n for img in images_list_unlab:\n if results_dorsal[img] < results_palmar[img]:\n final_results[img] = \"dorsal\"\n else:\n final_results[img] = \"palmar\"\n\n actual_labels = fetch_actual_labels(images_list_unlab)\n print(\"Classification\")\n no_correct = 0\n correctly_classified = []\n incorrectly_classified = []\n print(\"| ImageId | Prediction | Actual |\")\n for r in final_results:\n print(\"| {} | {} | {} |\".format(r, final_results[r], actual_labels[r]))\n if final_results[r] == actual_labels[r]:\n correctly_classified.append(r)\n no_correct += 1\n else:\n incorrectly_classified.append(r)\n\n print(\"Correctly classified: {}\\n\".format(correctly_classified))\n print(\"InCorrectly classified: {}\\n\".format(incorrectly_classified))\n\n print(\"Classification Accuracy: {}%\".format(no_correct / len(images_list_unlab) * 100))\n print(\"Execution time: {} seconds\".format(time.time() - start))","def implement_processing(self, output_intermediate, processing_matrix, forward = True):\n \n # Attention implementation\n output_intermediate = torch.matmul(output_intermediate, processing_matrix)\n output_intermediate = torch.transpose(output_intermediate,2,1)\n \n # Linear layer output reduction \n # from [batch, hidden_size, input_size - 1] to [batch, hidden_size,1]\n # different linear layers required to ensure good performance\n if forward:\n output_reduced = self.linear_fw(output_intermediate).squeeze(2)\n else:\n output_reduced = self.linear_bw(output_intermediate).squeeze(2)\n \n output_reduced = self._activation_fn(output_reduced)\n \n return output_reduced","def estimateInfo(Analysis, ImageData, diffract, print_opt=False): \n total_images = ImageData['totalImages'] \n\n for key in Analysis:\n Analysis[key]['cones'] = [1,2,3,4,5,6]\n Analysis[key]['info'] = np.zeros(len(\n Analysis[key]['cones']))\n\n for amp in ImageData['rawAmp']:\n\n for key in Analysis:\n ind = len(diffract['cpd'])\n fooInfo = info.SingleConeEntropyFunc((amp[ind] ** 2 *\n Analysis[key]['retina']), \n Analysis[key]['cones']) \n Analysis[key]['info'] += fooInfo / total_images\n\n if print_opt == True:\n print ' '\n print 'Information'\n print '------------'\n for key in Analysis:\n print key, ': ', Analysis[key]['info']\n\n return Analysis","def _process_matrices(self, **kwargs):\n\n if self.datasource == 'graph':\n # Must store the adj_matrix\n self.data.adjacencymat = self.data.adj_matrix()\n return self._sum_on_axis(self.data.adjacencymat, **kwargs)\n elif self.datasource == 'custom':\n return self._sum_on_axis(self.data, **kwargs)\n elif self.datasource == 'MRD':\n return {k: self._sum_on_axis(self.data.data[k].todense(), undirected=False) for k in self.data.data.keys() if k != 'pk'}","def sublayer_reconstruct(self, layer, sublayer, timesurface, method,\n noise_ratio, sparsity_coeff, sensitivity):\n if method == \"CG\":\n error = self.sublayer_response_CG(layer, sublayer,\n timesurface,\n sparsity_coeff,\n noise_ratio)\n if method == \"Exp distance\": \n error = self.sublayer_response_exp_distance(layer, sublayer,\n timesurface,\n sparsity_coeff, \n noise_ratio, \n sensitivity)\n if method==\"Dot product\":\n error = self.sublayer_response_dot_product(layer, sublayer,\n timesurface,\n sparsity_coeff, \n noise_ratio, \n sensitivity)\n print(\"Layer activity : \")\n print(self.activations[layer][sublayer]) \n S_tilde = sum([a*b for a,b in zip(self.basis[layer][sublayer],\n self.activations[layer][sublayer])]) \n plt.figure(\"Reconstructed Figure\")\n sns.heatmap(S_tilde)\n print(\"Reconstruction error : \")\n print(error)\n return error","def cal_topology_feature(self):\n self.NPL()\n self.topo_efficiency_cal()\n self.efficiency_cal()\n self.cluster_cal()\n self.topo_diameter()\n self.spatial_diameter()","def data_model_residual(surface, dem, unw, incidence):\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\n\n # Using image_grid\n fig = plt.figure()\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (1, 3),\n direction=\"row\",\n axes_pad = 0.05,\n add_all=True,\n label_mode = \"1\",\n share_all = True,\n cbar_location=\"top\",\n cbar_mode=\"each\", #\"single\"\n cbar_size=\"5%\",\n cbar_pad=0.05,\n )\n #grid[0].set_xlabel(\"X\")\n #grid[0].set_ylabel(\"Y\")\n #grid2[0].set_xticks([-2, 0])\n #grid2[0].set_yticks([-2, 0, 2])\n\n #NOTE: could find global min/max from three arrays here\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\n #for ax,data in zip(grid,[los,fem_los,residual]):\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\n grid[0].axhline(100,color='m') #show profile\n cax = grid.cbar_axes[0]\n cax.colorbar(im)\n grid[1].axhline(100,color='k') #show profile\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\n\n cax = grid.cbar_axes[1]\n cax.colorbar(im1)\n\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\n cax = grid.cbar_axes[2]\n cax.colorbar(im2)\n\n # Add letter labels\n for ax, label in zip(grid,['A', 'B', 'C']):\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\n fontsize=16, fontweight='bold', va='top')\n\n # Annotate\n # NOTE: way too high!\n #plt.suptitle('FEM Results')\n\n # Add profile\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\n fig = plt.figure()\n #x = arange(los.shape[0])\n plt.axhline(color='k',ls='--')\n plt.plot(los[100],'m.',label='data')\n plt.plot(fem_los[100],'k-',lw=2,label='model')\n plt.xlabel('Distance [km]')\n plt.ylabel('Distance [km]')\n plt.legend(loc='upper left')\n\n plt.show()","def data_augmentation_and_vectorization(self,imlist, lb,im_labels, average_image = None):\n\t\tX,Y,X_original = [] ,[], []\n\n\t\ti = 0\n\t\tfor im in imlist:\n\t\t\tim=Image.fromarray(im,mode=self.mode)\n\t\t\t#try:\n\t\t\t#im_ini = im\n\t\t\tim_original = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t#im = self.substract_average_image(im, average_image)\n\t\t\t#print 'i:{} is a: {}' .format(i,im_labels[i])\n\t\t\t#im.show()\n\t\t\tX_original.append(im_original)\n\n\t\t\t#Rotations \n\t\t\t#im_r = im.rotate(15)\n\t\t\t# im_r_2 = im.rotate(-15)\n\t\t\t# im_r_3 = im.rotate(180)\n\t\t\t#im_r.show()\n\t\t\t#im_r_2.show()\n\n\t\t\t#Filters\n\t\t\t#im_f = im_ini.filter(ImageFilter.DETAIL)\n\t\t\t#im_f = im.filter(ImageFilter.FIND_EDGES)\n\t\t\t\n\t\t\tif self.mode == 'RGB':\n\t\t\t\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t\t#Uncomment this if you want to use cross-correlate for 2D arrays http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.signal.correlate2d.html\n\t\t\t\t# im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\t# im = sp.inner(im, [299, 587, 114]) / 1000.0\n\t\t\t\t# im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\n\t\t\t\t# im = (im - im.mean()) / im.std()\n\n\t\t\tif self.mode == 'L':\n\t\t\t\t# im = np.asarray(im, dtype='float64')\n\t\t\t\t# im = filters.sobel(im)\n\t\t\t\t#im = filters.roberts(im)\n\t\t\t\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\n\t\t\t#im = np.asarray(im, dtype=np.uint8)\n\t\t\t#print im.shape\n\t\t\t#print im.shape\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t#im = self.flaten_aux(im)\n\t\t\t#print im.shape\n\t\t\t#im = data.coins() # or any NumPy arr\n\t\t\t#print im.shape\n\t\t\t#image = data.coins() # or any NumPy array!\n\t\t\t#print im\n\t\t\t#im = filter.sobel(im)\n\t\t\t#im = filter.roberts(im)\n\n\t\t\t# im_original = sp.inner(im, [299, 587, 114]) / 1000.0\n\t\t\t# im_original = np.asarray(im_original, dtype=theano.config.floatX)\n\t\t\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\n\t\t\t# im = (im_original - im_original.mean()) / im_original.std()\n\t\t\t#print im.shape\n\t\t\t#print edges\n\t\t\t# edges = np.asarray(edges, dtype=np.uint8)\n\t\t\t#Image.fromarray(edges,mode=self.mode).show()\n\n\t\t\t#print edges\n\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX) / 256.\n\n\t\t\t#print edges.shape\n\t\t\t# io.imshow(im)\n\t\t\t# io.show()\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\n\t\t\t# plt.suptitle(im_labels[i], size=16)\n\t\t\t# plt.imshow(im, cmap=plt.cm.gray, interpolation='nearest')\n\t\t\t# plt.show()\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t#print im.shape\n\t\t\t#self.reconstructImage(im).show()\n\n\t\t\t#im_r = np.asarray(im_r, dtype=theano.config.floatX) / 256.\n\t\t\t# im_r_2 = np.asarray(im_r_2, dtype=theano.config.floatX) / 256.\n\t\t\t# im_r_3 = np.asarray(im_r_3, dtype=theano.config.floatX) / 256.\n\t\t\t#im_f = np.asarray(im_f, dtype=theano.config.floatX) / 256.\n\t\t\t\n\t\t\t#im = im.transpose(2, 0, 1)\n\t\t\t#X.append(np.array(im, dtype=theano.config.floatX))\n\t\t\t#X.append(np.array(im_raw, dtype=theano.config.floatX))\n\t\t\t#X.append(im)\n\t\t\tX.append(im)\n\t\t\t# if i % 100 == 0:\n\t\t\t# \tX.append(im)\n\t\t\t#X.append(im_r)\n\t\t\t# X.append(im_r_2)\n\t\t\t# X.append(im_r_3)\n\t\t\t#X.append(im_f)\n\t\t\t#X_original.append(im)\n\n\t\t\t# X.append(np.array(im_r, dtype=theano.config.floatX))\n\t\t\t# X.append(np.array(im_r_2, dtype=theano.config.floatX))\n\n\t\t\t#Uncomment this if you want to work with monochrome\n\t\t\t# im = im.convert('L')\n\t\t\t# pixels_monochrome = np.array(list(im.getdata()), dtype=np.float)\n\t\t\t\t\t\t\n\t\t\t# # scale between 0-1 to speed up computations\n\t\t\t# min_max_scaler = preprocessing.MinMaxScaler(feature_range=(0,1), copy=True)\n\t\t\t# pixels_monochrome = min_max_scaler.fit_transform(pixels_monochrome)\n\n\t\t\t# X.append(pixels_monochrome)\n\n\t\t\t#Y.append(lb.transform([im_labels[i]])[0][0])\n\t\t\t#print lb.transform([im_labels[i]])\n\t\t\t\n\t\t\tlabel = lb.transform([im_labels[i]])[0][0]\n\t\t\t#print lb.transform([im_labels[i]])\n\t\t\t# label_vector = lb.transform([im_labels[i]])[0]\n\t\t\t# label = np.where( label_vector == 1 )[0][0]\n\t\t\t# print \"Label: {}\".format(label)\n\t\t\t#print label\n\t\t\t#Y.append(label)\n\t\t\tY.append(label)\n\t\t\t#Y.append(im_labels[i])\t\n\n\t\t\t\n\t\t\t#Y.append(label)\t\n\t\t\t# Y.append(label)\t\n\t\t\t# except Exception, e:\n\t\t\t# \tprint e\n\t\t\t# \t#raise e\n\n\t\t\t# if i == 30:\n\t\t\t# \tbreak\n\n\t\t\ti += 1\n\t\t\tif self.verbose:\n\t\t\t\tsys.stdout.write(\"\\r Process: {0}/{1}\".format(i, len(imlist)))\n\t\t\t\tsys.stdout.flush()\n\t\t\n\t\t# output = open(self.data_path + 'X_original.pkl', 'wb')\n\t\t# cPickle.dump(X_original, output,protocol=-1)\n\t\t# output.close()\n\n\t\treturn X,Y","def combined_costs(matrix_MSLL_IO):\r\n return","def mutual_information_3d(self,max_lag,percent_calc=.5,digitize=True):\n\n if digitize:\n M = utilities.mi_digitize(self.X)\n else:\n M = self.X\n\n rs, cs, zs = np.shape(M)\n\n rs_iters = int(rs*percent_calc)\n cs_iters = int(cs*percent_calc)\n\n r_picks = np.random.choice(np.arange(rs),size=rs_iters,replace=False)\n c_picks = np.random.choice(np.arange(cs),size=cs_iters,replace=False)\n\n\n # The r_picks are used to calculate the MI in the columns\n # and the c_picks are used to calculate the MI in the rows\n\n c_mi = np.zeros((rs_iters,max_lag))\n r_mi = np.zeros((cs_iters,max_lag))\n\n for i in range(rs_iters):\n for j in range(max_lag):\n\n rand_z = np.random.randint(0,zs)\n ind = j+1\n unshift = M[r_picks[i],ind:,rand_z]\n shift = M[r_picks[i],:-ind,rand_z]\n c_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\n\n for i in range(cs_iters):\n for j in range(max_lag):\n\n rand_z = np.random.randint(0,zs)\n ind=j+1\n unshift = M[ind:, c_picks[i],rand_z]\n shift = M[:-ind, c_picks[i],rand_z]\n r_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\n\n #for the z dimension\n rs,cs = np.where(np.random.rand(rs,cs)=2014))\n\n dms_cube.var_name = 'field570'\n dms_cube.attributes.pop('name')\n dms_cube.coord('time').var_name = 'time'\n dms_cube.coord('time').long_name = 'time'\n\n fut_cube_high = fut_cube_high[:-2]\n fut_cube_surf = fut_cube_surf[:-2]\n\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\n\n #Save the final cubes as netcdf (cutting them to be the same length)\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \"SO2DMS_rcp262015.nc\")\n os.system('ncatted -O -a calendar,time,m,c,\"360_day\" '+data_dir+ \"SO2DMS_rcp262015.nc\")\n\n return","def L14_Net112(mode=\"train\"):\n data = mx.symbol.Variable(name=\"data\")\n landmark_target = mx.symbol.Variable(name=\"landmark_target\")\n landmark_vis = mx.symbol.Variable(name=\"landmark_vis\")\n \n # data = 112X112\n # conv1 = 56X56\n conv1 = Conv(data, num_filter=res_base_dim, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name=\"conv1\")\n conv2 = Residual(conv1, num_block=1, num_out= res_base_dim, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim, name=\"res2\")\n \n\t#conv23 = 28X28\n conv23 = DResidual(conv2, num_out=res_base_dim*2, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=res_base_dim*2, name=\"dconv23\")\n conv3 = Residual(conv23, num_block=2, num_out=res_base_dim*2, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim*2, name=\"res3\")\n \n\t#conv34 = 14X14\n conv34 = DResidual(conv3, num_out=res_base_dim*4, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=res_base_dim*4, name=\"dconv34\")\n conv4 = Residual(conv34, num_block=3, num_out=res_base_dim*4, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim*4, name=\"res4\")\n \n\t#conv45 = 7X7\n conv45 = DResidual(conv4, num_out=res_base_dim*8, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=res_base_dim*8, name=\"dconv45\")\n conv5 = Residual(conv45, num_block=2, num_out=res_base_dim*8, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim*8, name=\"res5\")\n \n\t# conv6 = 1x1\n conv6 = Conv(conv5, num_filter=res_base_dim*8, kernel=(7, 7), pad=(0, 0), stride=(1, 1), name=\"conv6\")\n fc1 = Conv(conv6, num_filter=res_base_dim*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name=\"fc1\")\n fc2 = Conv(fc1, num_filter=res_base_dim*32, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name=\"fc2\")\t\n conv6_3 = mx.symbol.FullyConnected(data=fc2, num_hidden=42, name=\"conv6_3\")\t\n bn6_3 = mx.sym.BatchNorm(data=conv6_3, name='bn6_3', fix_gamma=False,momentum=0.9)\n\t\n if mode == \"test\":\n landmark_pred = bn6_3\n group = mx.symbol.Group([landmark_pred])\n else:\n \n out = mx.symbol.Custom(landmark_vis = landmark_vis, landmark_pred=bn6_3, landmark_target=landmark_target, \n op_type='negativemining_hand21', name=\"negative_mining\")\n group = mx.symbol.Group([out])\n \n return group","def calculate(self, inputs):\r\n output = inputs\r\n for layer in self.layers:\r\n output = layer.calculate(output)\r\n return output","def calculate_correlations(input_data, index_col, cat_features, exclu_elements): \r\n try:\r\n # encode the categorical features\r\n encoded_data = pd.get_dummies(input_data,columns=cat_features,drop_first=True)\r\n\r\n pd_transposed_data = encoded_data.set_index('Style_display_code').T\r\n\r\n # get the number of items\r\n items_list = [str(a) for a in pd_transposed_data.columns]\r\n\r\n print(\"Number of items to correlate :{}_Timestamp:{}\".format(str(len(items_list)), \r\n format(str(datetime.now()))))\r\n \r\n\r\n #compute correlations and save the pickle file\r\n# matrix = pd_transposed_data.corr().values\r\n# pickle.dump(matrix, open(staging_dir+ '/corr_matrix_output_py3.p', 'wb'))\r\n \r\n # read from the saved pickle file - ONLY FOR CONSECUTIVE RUNS, TO SAVE TIME\r\n matrix = pickle.load(open(staging_dir+ '/corr_matrix_output_py3.p', \"rb\" ) )\r\n\r\n print(\"Corr Matrix size:{}_Timestamp:{}\".format(str(matrix.size),\r\n format(str(datetime.now()))))\r\n\r\n except Exception as e:\r\n print(\" Error !!\", e)\r\n \r\n # return the top correlated items\r\n return top_correlateditems(items_list,matrix, index_col, exclu_elements)","def CVNeuralNetLayers(\n theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires\n):\n\n wires = Wires(wires)\n repeat = _preprocess(\n theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires\n )\n\n for l in range(repeat):\n\n Interferometer(theta=theta_1[l], phi=phi_1[l], varphi=varphi_1[l], wires=wires)\n\n r_and_phi_r = qml.math.stack([r[l], phi_r[l]], axis=1)\n broadcast(unitary=Squeezing, pattern=\"single\", wires=wires, parameters=r_and_phi_r)\n\n Interferometer(theta=theta_2[l], phi=phi_2[l], varphi=varphi_2[l], wires=wires)\n\n a_and_phi_a = qml.math.stack([a[l], phi_a[l]], axis=1)\n broadcast(unitary=Displacement, pattern=\"single\", wires=wires, parameters=a_and_phi_a)\n\n broadcast(unitary=Kerr, pattern=\"single\", wires=wires, parameters=k[l])","def create(self):\n \n \"\"\" A solo prepressing reduction network in the head \"\"\"\n print(\"pre_reduction\")\n with tf.name_scope('pre_reduction'):\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\n \n \"\"\" 1st inception layer group \"\"\"\n print(\"icp1\")\n with tf.name_scope('icp1'):\n # branch 0\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\n # branch 1\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\n # branch 2\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\n # branch 3\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\n # concat\n icp2_in = NW.concat([icp1_out0,\n icp1_out1,\n icp1_out2,\n icp1_out3], 3, 'icp2_in')\n\n \"\"\" 2nd inception layer group \"\"\"\n print(\"icp2\")\n with tf.name_scope('icp2'):\n # branch 0\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\n # branch 1\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\n # branch 2\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\n # branch 3\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\n # concat\n icp2_out = NW.concat([icp2_out0,\n icp2_out1,\n icp2_out2,\n icp2_out3], 3, 'icp2_out')\n \n \"\"\" 3rd inception layer group \"\"\"\n print(\"icp3\")\n with tf.name_scope('icp3'):\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\n # branch 0\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\n # branch 1\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\n # branch 2\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\n # branch 3\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\n # concat\n icp3_out = NW.concat([icp3_out0,\n icp3_out1,\n icp3_out2,\n icp3_out3], 3, 'icp3_out')\n \n \"\"\" 1st classify branch \"\"\"\n with tf.name_scope('cls1'):\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\n self.layers[\"cls1_fc_pose_xy\"] = cls1_fc_pose_xy\n self.layers[\"cls1_fc_pose_ab\"] = cls1_fc_pose_ab\n \n \"\"\" 4st inception layer group \"\"\"\n print(\"icp4\")\n with tf.name_scope('icp4'):\n # branch 0\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\n # branch 1\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\n # branch 2\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\n # branch 3\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\n # concat\n icp4_out = NW.concat([icp4_out0,\n icp4_out1,\n icp4_out2,\n icp4_out3],3, name='icp4_out')\n\n \"\"\" 5st inception layer group \"\"\"\n print(\"icp5\")\n with tf.name_scope('icp5'):\n # branch 0\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\n # branch 1\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\n # branch 2\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\n # branch 3\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\n # concat\n icp5_out = NW.concat([icp5_out0, \n icp5_out1, \n icp5_out2, \n icp5_out3], 3, name='icp5_out')\n \n \"\"\" 6st inception layer group \"\"\"\n print(\"icp6\")\n with tf.name_scope('icp6'):\n # branch 0\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\n # branch 1\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\n # branch 2\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\n # branch 3\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\n # concat\n icp6_out = NW.concat([icp6_out0,\n icp6_out1,\n icp6_out2,\n icp6_out3], 3, name='icp6_out')\n\n \"\"\" 2nd classify branch \"\"\"\n with tf.name_scope('cls2'):\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\n self.layers[\"cls2_fc_pose_xy\"] = cls2_fc_pose_xy\n self.layers[\"cls2_fc_pose_ab\"] = cls2_fc_pose_ab\n\n \"\"\" 7st inception layer group \"\"\"\n print(\"icp7\")\n with tf.name_scope('icp7'):\n # branch 0\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\n # branch 1\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\n # branch 2\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\n # branch 3\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\n # concat\n icp7_out = NW.concat([icp7_out0,\n icp7_out1,\n icp7_out2,\n icp7_out3], 3, name='icp7_out')\n\n \"\"\" 8st inception layer group \"\"\"\n print(\"icp8\")\n with tf.name_scope('icp8'):\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\n # branch 0\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\n # branch 1\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\n # branch 2\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\n # branch 3\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\n # concat\n icp8_out = NW.concat([icp8_out0,\n icp8_out1,\n icp8_out2,\n icp8_out3], 3, name='icp8_out')\n \n \"\"\" 9st inception layer group \"\"\"\n print(\"icp9\")\n with tf.name_scope('icp9'):\n # branch 0\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\n # branch 1\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\n # branch 2\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\n # branch 3\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\n # concat\n icp9_out = NW.concat([icp9_out0,\n icp9_out1,\n icp9_out2,\n icp9_out3], 3, name='icp9_out')\n\n \"\"\" 3rd classify branch \"\"\"\n with tf.name_scope('cls3'):\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\n self.layers[\"cls3_fc_pose_xy\"] = cls3_fc_pose_xy\n self.layers[\"cls3_fc_pose_ab\"] = cls3_fc_pose_ab","def forward(self, img):\n device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n H, W = img.size()[2], img.size()[3]\n #print('x',x)\n #print('x.shape',x.shape) ## 32 x 3 x 96 x 128\n z32 = self.start(img)\n z64 = self.layer1(z32) + self.layer1_ds(z32)\n #print('z1',z64.shape)\n z128 = self.layer2(z64) + self.layer2_ds(z64)\n #print('z2',z128.shape)\n z256 = self.layer3(z128) + self.layer3_ds(z128)\n #print('z3',z256.shape)\n z256d = self.drop_out_layer(z256)\n #print('z_drop',z256d.shape)\n z256u = self.layer4(z256d)\n #print('z4',z256u.shape)\n z128u = self.layer5(torch.cat((z256u, F.interpolate(z256d,size=z256u.size()[2:] )), 1))\n #print('z5',z128u.shape)\n z64u = self.layer6(torch.cat((z128u, F.interpolate(z128,size=z128u.size()[2:] )), 1))\n #print('z6',z64u.shape)\n\n z32u = self.final(torch.cat((z64u, F.interpolate(z64,size=z64u.size()[2:] )), 1))\n #print('z6_plus',z32u.shape)\n\n #print('z7_result',self.classifer(z32u)[:, :, :H, :W].shape)\n result_class = self.classifer(z32u)[:, :, :H, :W]\n\n #print('model result shape',result_class.shape)\n ## 16 x 1 x 300 x 400\n\n # using soft argmax\n spa_argmax = spatial_argmax(torch.squeeze(result_class,1))\n\n #one hot with spatial argmax\n #xy_val = torch.zeros(spa_argmax.shape).float()\n #for idx, pt in enumerate(spa_argmax):\n # x_val = (pt[0]+1.0)*63.5\n # y_val = (pt[1]+1.0)*47.5\n # # for each batch. [0...127][0...95]\n # xy_val[idx][0] = x_val\n # xy_val[idx][1] = y_val\n\n xy_val = (spa_argmax+1.0).to(device)\n #print('spa_argmax',spa_argmax)\n scaling_factor = torch.FloatTensor([[(W-1)/2,0.],[0.,(H-1)/2]]).to(device)\n #scaling_factor = torch.FloatTensor([[63.5,0.],[0.,44.5]]).to(device)\n xy_val = xy_val.mm(scaling_factor)\n\n return xy_val","def method3(self):\n cres=0.\n Ux_aloc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy_aloc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.ALDM[ix ,iy, : , : ]\n mat2=self.ALDM[(ix%self.kS.Nx)+1, iy, : , : ]\n mat3=self.ALDM[ix ,(iy%self.kS.Ny)+1, : , : ]\n \n Ux_aloc[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[self.NL-1:,self.NL-1:])\n Uy_aloc[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[self.NL-1:,self.NL-1:])\n\n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux_aloc[ix,iy]*Uy_aloc[ix+1,iy]/Ux_aloc[ix,iy+1]/Uy_aloc[ix,iy])\n cres+=ftemp/2./pi/1j\n \n return cres.real\n #End of method3","def learn(self):\r\n \r\n # unpack\r\n X = self.Train.X\r\n Y = self.Train.Y\r\n DY = self.Train.DY\r\n \r\n NX ,ND = X.shape\r\n NDY,_ = DY.shape\r\n \r\n print 'Build Information Matricies ...'\r\n \r\n # functions\r\n ay0 = np.array([[1.]]*NX)\r\n ay1 = X\r\n ay2 = np.reshape( np.einsum('ij,ik->ijk',X,X) , [-1,ND*ND] )\r\n\r\n # reduce redundant basis variables\r\n i_doub = np.tri(ND,k=-1).T == 1\r\n ay2[:,i_doub.ravel()] = ay2[:,i_doub.ravel()] * 2. \r\n i_keep = np.tri(ND,k=0).T == 1\r\n ay2 = ay2[:,i_keep.ravel()]\r\n\r\n # basis matrix, functions\r\n Ay = np.hstack([ay0,ay1,ay2])\r\n \r\n # arrays for the least squares regression\r\n At = Ay\r\n Yt = Y\r\n \r\n # gradients\r\n if NDY:\r\n ad0 = np.array([[0.]]*NX*ND)\r\n \r\n ad1 = np.tile( np.eye(ND) , [NX,1] )\r\n \r\n ad2a = np.repeat( np.eye(ND)[:,None,:] , ND , 1 )\r\n ad2a = np.reshape( ad2a , [-1,ND*ND] ) \r\n ad2a = np.repeat( ad2a, NX, axis=0 ) * np.repeat( np.tile( X, [ND,1] ) , ND, axis=1 )\r\n \r\n ad2b = np.repeat( np.eye(ND)[:,:,None] , ND , 2 )\r\n ad2b = np.reshape( ad2b , [-1,ND*ND] ) \r\n ad2b = np.repeat( ad2b, NX, axis=0 ) * np.tile( np.tile( X, [ND,1] ) , [1,ND] )\r\n \r\n ad2 = ad2a + ad2b\r\n \r\n # reduce redundant bases\r\n ad2[:,i_doub.ravel()] = ad2[:,i_doub.ravel()] * 2.\r\n ad2 = ad2[:,i_keep.ravel()] \r\n \r\n Ad = np.hstack([ad0,ad1,ad2])\r\n \r\n # add to arrays for least squares regression\r\n At = np.vstack([At,Ad])\r\n Yt = np.vstack([Yt, np.ravel(DY.T)[:,None]])\r\n \r\n print 'Least Squares Solve ...'\r\n B = sp.linalg.lstsq(At,Yt)[0] \r\n \r\n # unpack data\r\n c = B[0,0]\r\n b = B[1:ND+1]\r\n \r\n A = np.zeros([ND,ND])\r\n A[i_keep] = B[ND+1:,0]\r\n A[i_keep.T] = A.T[i_keep.T]\r\n \r\n # problem forumulation\r\n A = A*2.\r\n \r\n # store results\r\n self.c = c\r\n self.b = b\r\n self.A = A\r\n \r\n print ''","def neuron_stats_to_layer(neuron_info, input_layer_count, input_neurons_per_layer, network_info, target_column=\"synapse_count\"):\n # assuming the first neuron in neuron\n input_layer = list()\n\n input_neuron_ids = neuron_info[ neuron_info.ids < 0].ids.values - np.min(neuron_info.ids)\n input_neuron_values = neuron_info[ neuron_info.ids < 0][target_column]\n\n input_collector = np.zeros((input_layer_count, input_neurons_per_layer))\n\n for inp_l in range(input_layer_count):\n mask_above_first = inp_l * input_neurons_per_layer <= input_neuron_ids\n below_last = input_neuron_ids < (inp_l + 1 ) * input_neurons_per_layer\n\n mask = mask_above_first & below_last\n\n ids_for_this_layer = input_neuron_ids[mask] - inp_l * input_neurons_per_layer\n\n input_collector[inp_l, ids_for_this_layer] = input_neuron_values[mask]\n\n # now the normal layers\n normal_neuron_info = neuron_info[ neuron_info.ids >= 0]\n\n\n exc_collector = np.zeros((network_info[\"num_layers\"], network_info[\"num_exc_neurons_per_layer\"]))\n inh_collector = np.zeros((network_info[\"num_layers\"], network_info[\"num_inh_neurons_per_layer\"]))\n\n layerwise = helper.split_into_layers(normal_neuron_info, network_info)\n for l_id, layer in enumerate(layerwise):\n exc, inh = helper.split_exc_inh(layer, network_info)\n exc_collector[l_id, exc.ids] = exc[target_column].values\n inh_collector[l_id, inh.ids] = inh[target_column].values\n\n return input_collector, exc_collector, inh_collector","def method2(self):\n cres=np.zeros(self.NL,dtype=float) # List of invariants\n # The U matrices from Fukui's method; storage...\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n for il in range(self.NL):\n # ... and calculation of U matrices for each layer\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.LDM[il,ix ,iy ,:,:]\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\n \n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\n \n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\n \n return cres","def mutual_information_spatial(self,max_lag,percent_calc=.5,digitize=True):\n if digitize:\n M = utilities.mi_digitize(self.X)\n else:\n M = self.X\n\n rs, cs = np.shape(M)\n\n rs_iters = int(rs*percent_calc)\n cs_iters = int(cs*percent_calc)\n\n r_picks = np.random.choice(np.arange(rs),size=rs_iters,replace=False)\n c_picks = np.random.choice(np.arange(cs),size=cs_iters,replace=False)\n\n\n # The r_picks are used to calculate the MI in the columns\n # and the c_picks are used to calculate the MI in the rows\n\n c_mi = np.zeros((rs_iters,max_lag))\n r_mi = np.zeros((cs_iters,max_lag))\n\n for i in range(rs_iters):\n for j in range(max_lag):\n\n ind = j+1\n unshift = M[r_picks[i],ind:]\n shift = M[r_picks[i],:-ind]\n c_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\n\n for i in range(cs_iters):\n for j in range(max_lag):\n\n ind=j+1\n unshift = M[ind:, c_picks[i]]\n shift = M[:-ind, c_picks[i]]\n r_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\n\n r_mut = np.mean(r_mi,axis=0)\n c_mut = np.mean(c_mi,axis=0)\n\n return r_mut, c_mut, r_mi, c_mi","def cminfo_compute():\n from hera_mc import cm_sysutils \n h = cm_sysutils.Handling()\n cminfo = h.get_cminfo_correlator()\n snap_to_ant = {}\n ant_to_snap = {}\n for antn, ant in enumerate(cminfo['antenna_numbers']):\n name = cminfo['antenna_names'][antn]\n for pol in cminfo['correlator_inputs'][antn]:\n if pol.startswith('e'):\n e_pol = pol\n if pol.startswith('n'):\n n_pol = pol\n ant_to_snap[ant] = {}\n if e_pol != 'None':\n snapi_e, channel_e = snap_part_to_host_input(cminfo['correlator_inputs'][antn][0])\n ant_to_snap[ant]['e'] = {'host': snapi_e, 'channel': channel_e}\n if snapi_e not in snap_to_ant.keys():\n snap_to_ant[snapi_e] = [None] * 6\n snap_to_ant[snapi_e][channel_e] = name + 'E'\n if n_pol != 'None':\n snapi_n, channel_n = snap_part_to_host_input(cminfo['correlator_inputs'][antn][1])\n ant_to_snap[ant]['n'] = {'host': snapi_n, 'channel': channel_n}\n if snapi_n not in snap_to_ant.keys():\n snap_to_ant[snapi_n] = [None] * 6\n snap_to_ant[snapi_n][channel_n] = name + 'N'\n return snap_to_ant, ant_to_snap","def forward(self, images):\n features = self.resnet(images)\n features = Variable(features.data)\n features = self.pooling(features)\n # print(features)\n features = features.view(features.size(0),-1)\n # print(features)\n # print(resnet.fc.in_features)\n features = self.bn(self.linear(features))\n return features\n # with torch.no_grad():\n # features = self.resnet(images)\n # features = features.reshape(features.size(0), -1)\n # features = self.bn(self.linear(features))\n # return features","def forward(self, x):\n for name, module in self.base._modules.items():\n if name == 'avgpool':\n break\n\n if name == 'layer3':\n l2 = Variable(x)\n\n x = Variable(module(x))\n l4 = Variable(x)\n\n \"\"\"for name, param in self.base.named_parameters():\n print(name, param.size())\n\n res50_model = self.base\n res50_conv2 = ResNet50Bottom(res50_model)\n for i,child in enumerate(self.base.children()):\n print(i)\n if i==8:\n l4=x\n break\n if i==6:\n l2=x\n x=res50_conv2(x.detach())\"\"\"\n\n s2 = l2.sum(1) #/ 100\n #\n s4 = l4.sum(1) #/ 1000\n\n\n sw2 = s2 / (s2.view(x.size(0), -1).sum(1)).unsqueeze(1).unsqueeze(2)\n\n sw4 = s4 / (s4.view(x.size(0), -1).sum(1)).unsqueeze(1).unsqueeze(2)\n\n\n l2 = l2 * sw2.unsqueeze(1)\n l4 = l4 * sw4.unsqueeze(1)\n\n \n c2 = self.inconv2(l2)\n c4 = self.inconv4(l4)\n c2 = self.bn2(c2)\n c4 = self.bn4(c4)\n \n n2 = F.softmax(torch.mean(torch.mean(c2, dim=2), dim=2), dim=1)\n n4 = F.softmax(torch.mean(torch.mean(c4, dim=2), dim=2), dim=1)\n nn2 = n2.data.cpu().numpy()\n nn4 = n4.data.cpu().numpy()\n cam2 = np.zeros((x.size(0), 28, 28), dtype=float)\n cam4 = np.zeros((x.size(0), 7, 7), dtype=float)\n\n\n for i in range(0, x.size(0)):\n for j in range(0, 2):\n temp1 = c2[i, j, :, :].data.cpu().numpy()\n temp1 = np.maximum(temp1, 0)\n temp1 = temp1 - np.min(temp1)\n temp1 = temp1 / (np.max(temp1)+1e-8)\n cam2[i] = cam2[i] + nn2[i, j] * temp1\n cam2 = torch.FloatTensor(cam2)\n l2 = l2 * (cam2.unsqueeze(1).cuda())\n l2 = self.stack1(l2)\n l2 = self.stack1_1(l2)\n\n for i in range(0, x.size(0)):\n for j in range(0, 8):\n temp2 = c4[i, j, :, :].data.cpu().numpy()\n temp2 = np.maximum(temp2, 0)\n temp2 = temp2 - np.min(temp2)\n temp2 = temp2 / (np.max(temp2)+1e-8)\n cam4[i] =cam4[i] + nn4[i, j] * temp2\n cam4 = torch.FloatTensor(cam4)\n l4 = l4 * cam4.unsqueeze(1).cuda()\n l4 = self.stack3(l4)\n X = l2.view(x.size(0), 512, 7 ** 2)\n Y = l4.view(x.size(0), 512, 7 ** 2)\n Z = self.cross_bilinear(X, Y)\n return n2, n4, Z","def processAlgorithm(self, parameters, context, feedback):\n NO2_present_raster = self.parameterAsRasterLayer(parameters, self.INPUTNP, context)\n NO2_present_data_source = gdal.Open(NO2_present_raster.dataProvider().dataSourceUri())\n arr_NO2_present = NO2_present_data_source.GetRasterBand(1).ReadAsArray()\n\n PM10_present_raster = self.parameterAsRasterLayer(parameters, self.INPUTPP, context)\n PM10_present_data_source = gdal.Open(PM10_present_raster.dataProvider().dataSourceUri())\n arr_PM10_present = PM10_present_data_source.GetRasterBand(1).ReadAsArray()\n\n ozono_present_raster = self.parameterAsRasterLayer(parameters, self.INPUTOP, context)\n ozono_present_data_source = gdal.Open(ozono_present_raster.dataProvider().dataSourceUri())\n arr_ozono_present = ozono_present_data_source.GetRasterBand(1).ReadAsArray()\n\n arr_present = arr_ozono_present + arr_PM10_present + arr_NO2_present\n\n NO2_future_raster = self.parameterAsRasterLayer(parameters, self.INPUTNF, context)\n NO2_future_data_source = gdal.Open(NO2_future_raster.dataProvider().dataSourceUri())\n arr_NO2_future = NO2_future_data_source.GetRasterBand(1).ReadAsArray()\n\n PM10_future_raster = self.parameterAsRasterLayer(parameters, self.INPUTPF, context)\n PM10_future_data_source = gdal.Open(PM10_future_raster.dataProvider().dataSourceUri())\n arr_PM10_future = PM10_future_data_source.GetRasterBand(1).ReadAsArray()\n\n ozono_future_raster = self.parameterAsRasterLayer(parameters, self.INPUTOF, context)\n ozono_future_data_source = gdal.Open(ozono_future_raster.dataProvider().dataSourceUri())\n arr_ozono_future = ozono_future_data_source.GetRasterBand(1).ReadAsArray()\n\n arr_future = arr_ozono_future + arr_PM10_future + arr_NO2_future\n\n area_pixel = self.parameterAsInt(parameters, self.PIXEL_RES, context) * self.parameterAsInt(\n parameters, self.PIXEL_RES, context)\n\n NO2_euro_coeff = 77641.89\n ozono_euro_coeff = 14658.11\n PM10_euro_coeff = 17132.56\n\n arr_euro_present_NO2 = arr_NO2_present * NO2_euro_coeff\n arr_euro_present_ozono = arr_ozono_present * ozono_euro_coeff\n arr_euro_present_PM10 = arr_PM10_present * PM10_euro_coeff\n arr_value_present = arr_euro_present_PM10 + arr_euro_present_ozono + arr_euro_present_NO2\n\n arr_euro_future_NO2 = arr_NO2_future * NO2_euro_coeff\n arr_euro_future_ozono = arr_ozono_future * ozono_euro_coeff\n arr_euro_future_PM10 = arr_PM10_future * PM10_euro_coeff\n arr_value_future = arr_euro_future_PM10 + arr_euro_future_ozono + arr_euro_future_NO2\n\n arr_diff_NO2 = arr_euro_future_NO2 - arr_euro_present_NO2\n arr_diff_PM10 = arr_euro_future_PM10 - arr_euro_present_PM10\n arr_diff_ozono = arr_euro_future_ozono - arr_euro_present_ozono\n\n arr_diff_tot = arr_diff_NO2 + arr_diff_PM10 + arr_diff_ozono\n\n # Initialize and write on output raster\n path_output = self.parameterAsString(parameters, self.OUTPUT, context)\n file_output = path_output + '/SE_02_rimozione_inquinanti_delta_euro.tiff'\n driver = gdal.GetDriverByName(\"GTiff\")\n [cols, rows] = arr_NO2_present.shape\n diff_tot = np.sum(arr_diff_tot) / (cols * rows )\n outdata = driver.Create(file_output, rows, cols, 1, gdal.GDT_Float64)\n outdata.SetGeoTransform(NO2_present_data_source.GetGeoTransform()) ##sets same geotransform as input\n outdata.SetProjection(NO2_present_data_source.GetProjection()) ##sets same projection as input\n outdata.GetRasterBand(1).WriteArray(arr_diff_tot)\n print(np.max(outdata.GetRasterBand(1).ReadAsArray()))\n outdata.FlushCache()\n\n # Years\n present = self.parameterAsInt(parameters, self.INPUTPRE, context)\n future = self.parameterAsInt(parameters, self.INPUTFUT, context)\n report_output = path_output + '/SE_rimozione_inquinanti.txt'\n f = open(report_output, \"w+\")\n today = datetime.today().strftime('%Y-%m-%d-%H:%M:%S')\n f.write(\"Sommario dell'analisi della rimozione inquinanti\\n\")\n f.write(\"Data: \" + today +\"\\n\\n\\n\")\n f.write(\"Analisi stato di fatto\\n\\n\")\n f.write(\"Anno corrente: %i \\n\" % (present))\n f.write(\"Rimozione NO2 Stato attuale (ton): %f \\n\" % (np.sum(arr_NO2_present)))\n f.write(\"Rimozione PM10 Stato attuale (ton): %f \\n\" % (np.sum(arr_PM10_present)))\n f.write(\"Rimozione ozono Stato attuale (ton): %f \\n\" % (np.sum(arr_ozono_present)))\n f.write(\"Valore totale della rimozione inquinanti (€): %f \\n\\n\\n\" % (np.sum(arr_value_present)))\n f.write(\"Analisi stato di progetto\\n\\n\")\n f.write(\"Anno progetto: %i \\n\" % (future))\n f.write(\"Rimozione NO2 Stato di progetto (ton): %f \\n\" % (np.sum(arr_NO2_future)))\n f.write(\"Rimozione PM10 Stato di progetto (ton): %f \\n\" % (np.sum(arr_PM10_future)))\n f.write(\"Rimozione ozono Stato di progetto (ton): %f \\n\" % (np.sum(arr_ozono_future)))\n f.write(\"Valore totale della rimozione inquinanti (€): %f \\n\\n\\n\" % (np.sum(arr_value_future)))\n f.write(\"Differenze tra stato di progetto e stato attuale\\n\\n\")\n f.write(\"Anno progetto: %i - %i\\n\" % (present, future))\n f.write(\"Differenza della rimozione inquinanti (ton):: %f \\n\" % (np.sum(arr_future - arr_present)))\n f.write(\"Differenza sequestro inquinanti per unità di superficie (ton/ha): %f \\n\" % (\n np.sum(arr_future - arr_present) / (cols * rows * area_pixel) * 10000))\n f.write(\"Differenza in termini economici del SE Rimozione inquinanti (stato di progetto – stato attuale) (€):%d \\n\" % (\n np.sum(arr_diff_tot))) \n return {self.OUTPUT: 'Completed'}\n\n \n # ----------------------------------------------------------------------------------- \n # Copyright (c) 2021 Città di Torino.\n # \n # This material is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 2 of the License, or\n # (at your option) any later version.\n # \n # This program is distributed in the hope that it will be useful,\n # but WITHOUT ANY WARRANTY; without even the implied warranty of\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n # GNU General Public License for more details.\n # \n # You should have received a copy of the GNU General Public License\n # along with this program. If not, see http://www.gnu.org/licenses.\n # ----------------------------------------------------------------------------------- ","def run(layers):\n\n # Value above which people are regarded affected\n # For this dataset, 0 is no data, 1 is cloud, 2 is normal water level\n # and 3 is overflow.\n threshold = 0\n\n # Identify hazard and exposure layers\n inundation = get_hazard_layer(layers)\n\n [population] = get_exposure_layers(layers)\n\n # Extract data as numeric arrays\n D = inundation.get_data(nan=0.0) # Depth\n\n # Scale the population layer\n P = population.get_data(nan=0.0, scaling=True)\n I = numpy.where(D > threshold, P, 0)\n\n # Assume an evenly distributed population for Gender\n G = 0.5\n pregnant_ratio = 0.024 # 2.4% of women are estimated to be pregnant\n\n # Calculate breakdown\n P_female = P * G\n P_male = P - P_female\n P_pregnant = P_female * pregnant_ratio\n\n I_female = I * G\n I_male = I - I_female\n I_pregnant = I_female * pregnant_ratio\n\n # Generate text with result for this study\n total = str(int(sum(P.flat) / 1000))\n count = str(int(sum(I.flat) / 1000))\n\n total_female = str(int(sum(P_female.flat) / 1000))\n total_male = str(int(sum(P_male.flat) / 1000))\n total_pregnant = str(int(sum(P_pregnant.flat) / 1000))\n\n affected_female = str(int(sum(I_female.flat) / 1000))\n affected_male = str(int(sum(I_male.flat) / 1000))\n affected_pregnant = str(int(sum(I_pregnant.flat) / 1000))\n\n # Create raster object and return\n R = Raster(I,\n projection=inundation.get_projection(),\n geotransform=inundation.get_geotransform(),\n name='People affected',\n keywords={'total': total, 'count': count,\n 'total_female': total_female, 'affected_female': affected_female,\n 'total_male': total_male, 'affected_male': affected_male,\n 'total_pregnant': total_pregnant, 'affected_pregnant': affected_pregnant,\n })\n return R","def three_layer_neuralnetwork(X, model, y=None, reg=0.0,verbose=0):\n \n # Unpack weights\n W1, b1, W2, b2, W3, b3 = model['W1'], model['b1'], model['W2'], model['b2'],model['W3'],model['b3']\n N,D= X.shape\n\n assert W1.shape[0] == D, ' W1 2nd dimenions must match number of features'\n \n dW1,dW2,dW3,db1,db2,db3=np.zeros_like(W1),np.zeros_like(W2),np.zeros_like(W3),np.zeros_like(b1),np.zeros_like(b2),np.zeros_like(b3)\n # Compute the forward pass\n \n '''\n AffineLayer = X.dot(W1)+b1 \n ReluLayer,_ = relu_forward(AffineLayer)\n AffineLayer2 = ReluLayer.dot(W2) + b2\n ReluLayer2,_ = relu_forward(AffineLayer2)\n AffineLayer3 = ReluLayer2.dot(W3) + b3\n scores = AffineLayer3\n \n print X.shape\n print W1.shape\n print b1.shape\n print W2.shape\n print b2.shape\n print W3.shape\n print b3.shape\n '''\n affine_out1,cache1 = affine_forward(X, W1, b1)\n relu_out1,cache_relu1 = relu_forward(affine_out1)\n \n affine_out2,cache2 = affine_forward(relu_out1, W2, b2)\n relu_out2,cache_relu2 = relu_forward(affine_out2)\n \n affine_out3,cache3 = affine_forward(relu_out2, W3, b3)\n scores = affine_out3\n\n #if verbose:\n #print ['Layer {} Variance = {}'.format(i+1, np.var(l[:])) for i,l in enumerate([a1, a2, cache3[0]])][:]\n if y is None:\n return scores\n data_loss,d_softmax = softmax_loss(scores,y)\n data_loss += reg * (np.sum(W1*W1) + np.sum(W2*W2) + np.sum(W3*W3))\n '''\n max_scores = np.max(scores)\n scores -= max_scores\n correct_class_scores = scores[y,np.arange(N)]\n exp_score = np.exp(scores)\n sumexp = np.sum(exp_score,axis=0)\n loss_i = -correct_class_scores + np.log(sumexp)\n loss = np.sum(loss_i) / N \n ''' \t\n # Compute the backward pass\n \n d_affine_out3, dW3, db3 = affine_backward(d_softmax, cache3) \n d_relu2 = relu_backward(d_affine_out3, cache_relu2)\n \n d_affine_out2, dW2, db2 = affine_backward(d_relu2, cache2) \n d_relu1 = relu_backward(d_affine_out2, cache_relu1)\n \n d_affine_out1, dW1, db1 = affine_backward(d_relu1, cache1) \n \n #\n reg_loss = 0\n\n loss = data_loss + reg_loss\n grads = {'W1': dW1, 'b1': db1, 'W2': dW2, 'b2': db2,'W3':dW3,'b3':db3}\n \n return loss, grads","def optimize_correlation(self,dataloader,num_epochs=10, optimizer=None):\n print(\" Start Correlation optimizing...\")\n if optimizer is None:\n optimizer = optim.SGD(self.parameters(),lr=0.001,momentum=0.9)\n loss_sub_log = []\n for epoch in range(num_epochs):\n current_loss = float(0)\n # batch_num = 0\n for batch_idx, batch_data in enumerate(dataloader,start=0):\n data, labels = batch_data\n optimizer.zero_grad()\n forward_correlation_result = F.softmax(self.forward(data),dim=1)\n # labels_extended = labels.expand(forward_correlation_result.shape)\n labels_extended = torch.zeros(forward_correlation_result.shape)\n for idx, label in enumerate(labels):\n labels_extended[idx][label] = 1\n\n error = forward_correlation_result-labels_extended\n # print(forward_correlation_result[0])\n # print(labels_extended[0])\n # print(labels[0])\n loss = -correlation_loss(self.latest_hidden_out,error)\n loss.backward()\n optimizer.step()\n current_loss = loss.item()\n # batch_num+=1\n loss_sub_log.append(current_loss)\n print(f\" sub epoch {epoch} correlation loss: {-current_loss}\")\n\n return optimizer","def get_final_reconstruction(self):","def transformation(self):\n for key in self.combination_dict.keys():\n if self.combination_dict[key]['column_count'] == 2:\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'tem' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'tem':\n self.temporal_transformation(self.combination_dict[key])\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'cat' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'cat':\n self.categorical_transformation(self.combination_dict[key])\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num' and self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\n self.numerical_transformation(self.combination_dict[key])\n\n elif self.combination_dict[key]['column_count'] == 3:\n num_count = 0\n num_column = []\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num':\n num_count += 1\n num_column.append(0)\n elif self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\n num_count += 1\n num_column.append(1)\n elif self.data_dict[self.combination_dict[key]['column3']]['data_type'] == 'num':\n num_count += 1\n num_column.append(2)\n\n if num_count == 1:\n self.three_column_groupby_logic(self.combination_dict[key], num_column)\n\n m_score_pie = []\n m_score_bar = []\n m_score_line = []\n m_score_scatter = []\n # for key in self.scenario_dict:\n # if self.scenario_dict\n for key in self.scenario_dict:\n if math.isnan(self.scenario_dict[key][\"Scatter_chart_score\"]):\n m_score_scatter.append(0)\n else:\n m_score_scatter.append(self.scenario_dict[key][\"Scatter_chart_score\"])\n m_score_pie.append(self.scenario_dict[key][\"Pie_chart_score\"])\n m_score_bar.append(self.scenario_dict[key][\"Bar_chart_score\"])\n m_score_line.append(self.scenario_dict[key][\"Line_chart_score\"])\n\n m_score_pie /= np.max(m_score_pie)\n m_score_bar /= np.max(m_score_bar)\n m_score_line /= np.max(m_score_line)\n m_score_scatter /= np.max(m_score_scatter)\n m_score = [m_score_pie, m_score_bar, m_score_line, m_score_scatter]\n match_index = np.argmax(m_score, axis = 0)\n i = 0\n for key in self.scenario_dict:\n if match_index[i] == 0:\n self.scenario_dict[key][\"Chart_Type\"] = \"pie\"\n if match_index[i] == 1:\n self.scenario_dict[key][\"Chart_Type\"] = \"bar\"\n if match_index[i] == 2:\n self.scenario_dict[key][\"Chart_Type\"] = \"line\"\n if match_index[i] == 3:\n self.scenario_dict[key][\"Chart_Type\"] = \"scatter\"\n self.scenario_dict[key][\"m_score\"] = m_score[match_index[i]][i]\n i += 1\n\n return self.scenario_dict","def MR1():\n global CO1_OUTPUT, MR1_OUTPUT\n\n for b in range(MR1_OB):\n for f in range(MR1_OF):\n # Maxpool begins here\n for r in range(MR1_OR):\n for c in range(MR1_OC):\n frame = np.zeros(4)\n frame[0] = CO1_OUTPUT[b][f][r*2 ][c*2 ]\n frame[1] = CO1_OUTPUT[b][f][r*2+1][c*2 ]\n frame[2] = CO1_OUTPUT[b][f][r*2 ][c*2+1]\n frame[3] = CO1_OUTPUT[b][f][r*2+1][c*2+1]\n\n # ReLU begins here\n maximum = 0\n for i in range(4):\n if frame[i] > maximum:\n maximum = frame[i]\n\n MR1_OUTPUT[b][f][r][c] = maximum","def calculate_output(self):","def pca_reduction(X, ncomp=20):\n print('Performing dimensionality reduction ...')\n\n # PCA fitting\n pca = PCA(n_components=ncomp)\n weights = pca.fit_transform(X)\n basis = pca.components_\n\n # # Plot cumsum(explained_variance) versus component\n # plt.semilogy(pca.explained_variance_ratio_*100, 's')\n # plt.ylabel('Explained Variance Ratio (%)', size=20)\n # plt.xticks(size=20)\n # plt.xlabel('Component', size=20)\n # plt.yticks(size=20)\n # plt.show()\n\n print('Explained variance ratio : '+str(round(np.cumsum(pca.explained_variance_ratio_)[-1]*100, 2))+' %.')\n\n # pickle.dump(pca, '/../Data/GPmodel/pca_'+str(ncomp))\n\n # Some plots on PCA\n # plot_pca(basis, weights)\n\n return pca, weights","def residmapComparison():\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\n\n image_data = fits.getdata('dataFiles/6gev_image.fits')\n filename = get_pkg_data_filename('dataFiles/6gev_image.fits')\n hdu = fits.open(filename)[0]\n wcs = WCS(hdu.header)\n\n #Given the results of the fit, calculate the model\n modelData001 = np.zeros(srcmap001[0].shape)\n modelData03 = np.zeros(srcmap03[0].shape)\n\n file = open('plotsData/fitResults001.pk1','rb')\n fit001 = pickle.load(file)\n file.close()\n\n file = open('plotsData/fitResults03.pk1','rb')\n fit03 = pickle.load(file)\n file.close()\n\n\n for source in fit001:\n the_index = srcmap001.index_of(source)\n\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\n for source in fit03:\n the_index = srcmap03.index_of(source)\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\n\n fig = plt.figure(figsize=[12, 4.5])\n\n vmin = -25.0\n vmax = 25.0\n cbStep = 5.0\n ax = fig.add_subplot(121, projection=wcs)\n ax=plt.gca()\n ax.tick_params(direction='in')\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\n ax.add_patch(c)\n mappable=plt.imshow((image_data-np.sum(modelData001,axis=0)),cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')#\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('GC Point Source ($>6$ GeV)')\n cb = plt.colorbar(mappable, label='Residual counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb.ax.tick_params(width=0)\n\n\n ax2=fig.add_subplot(122, projection=wcs)\n ax2 = plt.gca()\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\n ax2.add_patch(c2)\n mappable2 = plt.imshow((image_data-np.sum(modelData03,axis=0)), cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('GC Extended Source ($>6$ GeV)')\n cb2 = plt.colorbar(mappable2, label='Residual counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb2.ax.tick_params(width=0)\n fig.tight_layout()\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\n #plt.savefig('plots/residComparison.pdf',bbox_inches='tight')\n plt.show()","def __update(self):\n\n # Make sure loads have been assigned to group\n if type(self.appliedLoad) == Load:\n self.appliedLoad = LoadSet(self.appliedLoad)\n elif type(self.appliedLoad) != LoadSet:\n raise TypeError(\"Applied load must be a Load or LoadSet\")\n\n # Begin Calculations\n _cg = self.cg # calculate the cg once to save computation time\n _appLoad = self.appliedLoad.totalForce\n _appMoment = self.appliedLoad.totalMoment\n\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\n soln_mat = np.zeros(len(self) * 3) # solution matrix\n\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\n\n for i, j in enumerate(cSet):\n # i = column fastener ID\n # j = column fastener set\n # Mx = yFz - zFy\n # My = zFx - xFz\n # Mz = xFy - yFx\n\n Fx = j[0]\n Fy = j[1]\n Fz = j[2]\n\n # fill in first three rows\n coef_mat[0][Fx] = 1 # sum of Fx\n coef_mat[1][Fy] = 1 # sum of Fy\n coef_mat[2][Fz] = 1 # sum of Fz\n\n # fill in fourth row (sum of Mx at CG)\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\n\n # fill in fifth row (sum of My at CG)\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\n\n # fill in sixth row (sum of Mz at CG)\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\n\n for u, w in enumerate(rSet):\n # u = row fastener ID\n # w = row fastener set\n\n rX = w[0]\n rY = w[1]\n rZ = w[2]\n\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\n\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\n\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\n\n # fill in the solution matrix (soln_mat)\n for i in range(3):\n soln_mat[i] = -_netLoad.force[i]\n soln_mat[i+3] = -_netLoad.moment[i]\n\n # fill in the remaining rows\n for i, j in enumerate(rSet):\n # i = fastener\n # j = row\n\n rX = j[0]\n rY = j[1]\n rZ = j[2]\n\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\n + _netLoad.moment[0])\n\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\n + _netLoad.moment[1])\n\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\n + _netLoad.moment[2])\n\n # Solve system of equations\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\n\n # Add resulting fastener loads to fastener objects\n for i, j in enumerate(cSet):\n rX = j[0]\n rY = j[1]\n rZ = j[2]\n\n F[i].force[0] = matSol[rX]\n F[i].force[1] = matSol[rY]\n F[i].force[2] = matSol[rZ]","def compute(self) -> Union[Tensor, Tuple[Tensor, Tensor]]:\n preds_dataloader = _get_dataloader(\n input_ids=dim_zero_cat(self.preds_input_ids),\n attention_mask=dim_zero_cat(self.preds_attention_mask),\n idf=self.idf,\n batch_size=self.batch_size,\n num_workers=self.num_threads,\n )\n target_dataloader = _get_dataloader(\n input_ids=dim_zero_cat(self.target_input_ids),\n attention_mask=dim_zero_cat(self.target_attention_mask),\n idf=self.idf,\n batch_size=self.batch_size,\n num_workers=self.num_threads,\n )\n\n info_lm_score = _infolm_compute(\n self.model,\n preds_dataloader,\n target_dataloader,\n self.temperature,\n self.idf,\n self.information_measure_cls,\n self.special_tokens_map,\n self.verbose,\n )\n\n if self.return_sentence_level_score:\n return info_lm_score.mean(), info_lm_score\n\n return info_lm_score.mean()","def _compute_carry_and_output(self, x, h_tm1, c_tm1):\n x_i, x_f, x_c, x_o = x\n h_tm1_i, h_tm1_f, h_tm1_c, h_tm1_o = h_tm1\n i = self.recurrent_activation(\n x_i + K.dot(h_tm1_i, self.recurrent_kernel[:, :self.units]))\n f = self.recurrent_activation(x_f + K.dot(\n h_tm1_f, self.recurrent_kernel[:, self.units:self.units * 2]))\n c = f * c_tm1 + i * self.activation(x_c + K.dot(\n h_tm1_c, self.recurrent_kernel[:, self.units * 2:self.units * 3]))\n o = self.recurrent_activation(\n x_o + K.dot(h_tm1_o, self.recurrent_kernel[:, self.units * 3:]))\n return c, o","def __init__(self):\n super(LinearAggregationLayer, self).__init__()","def compute_IC(self, n_params=1):\n self.IC = information_criterion(self, n_params=n_params)","def rebuild_the_laplacians():\n local_matrix = InteractomeInterface()\n local_matrix.full_rebuild()\n\n annot_matrix = AnnotomeInterface()\n annot_matrix.full_rebuild()","def global_analysis(tomo, b_th, c=18):\n\n ## Thesholding and Volume analysis\n if c == 6:\n con_mat = [ [[0, 0, 0], [0, 1, 0], [0, 0, 0]],\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]],\n [[0, 0, 0], [0, 1, 0], [0, 0, 0]] ]\n elif c == 18:\n con_mat = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]]]\n elif c == 26:\n con_mat = [[[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]\n else:\n raise ValueError\n tomo_lbl, num_lbls = sp.ndimage.label(tomo >= b_th, structure=np.ones(shape=[3, 3, 3]))\n tomo_out = np.zeros(shape=tomo.shape, dtype=int)\n lut = np.zeros(shape=num_lbls+1, dtype=int)\n\n ## COUNTING REGIONS METHODS\n # import time\n # hold_t = time.time()\n # for lbl in range(1, num_lbls + 1):\n # ids = tomo == lbl\n # feat_sz = len(ids)\n # tomo_out[ids] = feat_sz\n # # print('[1]:', lbl, 'of', num_lbls)\n # print time.time() - hold_t\n\n ## COUNTING PIXELS METHOD\n ## Count loop\n # cont, total = 0, np.prod(tomo.shape)\n # import time\n # hold_t = time.time()\n for x in range(tomo.shape[0]):\n for y in range(tomo.shape[1]):\n for z in range(tomo.shape[2]):\n id = tomo_lbl[x, y, z]\n lut[id] += 1\n # cont += 1\n # print('[1]:', cont, 'of', total)\n #\n ## Write loop\n # cont, total = 0, np.prod(tomo.shape)\n\n for x in range(tomo.shape[0]):\n for y in range(tomo.shape[1]):\n for z in range(tomo.shape[2]):\n id = tomo_lbl[x, y, z]\n if id > 0:\n tomo_out[x, y, z] = lut[id]\n # cont += 1\n # print('[1]:', cont, 'of', total)\n # print time.time() - hold_t\n\n return tomo_out","def multiply(self, layer):\n pass","def scalarInfo(img, cnt):\n\tm = cntInfo(img, cnt)\n\td = {\"perimeter\":m[\"perimeter\"], \"oreientation\":m[\"orientation\"], \"solidity\":m[\"solidity\"],\"height\":m[\"height\"], \"extent\":m[\"extent\"], \"aspect ratio\":m[\"aspect ratio\"], \"area\":m[\"area\"], \"sum intensity\":m[\"sum intensity\"], \"width\":m[\"width\"], \"equivalent diameter\": m[\"equivalent diameter\"], \"mean intensity\": m[\"mean intensity\"]}\n\treturn d","def dimensionality_reduction(dataset, algorithm, sampled_frac=0.05):\n num_samples = int(len(dataset.index)*sampled_frac)\n sample = dataset[:num_samples]\n category_labels = sample[\"Rings\"]\n sample = sample.drop(\"Rings\", axis =1)\n if algorithm ==\"PCA\":\n dim_reducer = PCA(n_components=3)\n if algorithm == \"MDS\":\n dim_reducer = MDS(n_components = 3)\n if algorithm ==\"TSNE\":\n dim_reducer = TSNE(n_components=3)\n if algorithm == \"isomap\":\n dim_reducer = Isomap(n_components=3)\n \n reduced_dataset = dim_reducer.fit_transform(sample)\n\n fig = plt.figure()\n plt.clf()\n ax = fig.add_subplot(111, projection='3d')\n\n plt.cla()\n ax.scatter(reduced_dataset[:,0], reduced_dataset[:,1], reduced_dataset[:,2],c=category_labels.astype(str),cmap=plt.cm.spectral)\n\n ax.view_init(azim=30)\n plt.show()\n \n # plt.scatter(reduced_dataset[:,0], reduced_dataset[:,1], c=category_labels.astype(str))\n # plt.xlabel(\"z1\")\n # plt.ylabel(\"z2\")\n # plt.show()","def _calculate_information_gain(self, cur_state, next_state):\n\n n = len(cur_state)\n information_gain_per_action = np.zeros((n, self.action_dim))\n\n prob_cur = self.classifier.get_class1_prob(obs=cur_state)\n prob_next = self.classifier.get_class1_prob(obs=next_state)\n information_gain_true = (prob_next - prob_cur).reshape(-1, 1)\n\n next_state_null = np.copy(next_state)\n next_state_null[:, -self.action_dim:] = self.classifier.missing_value\n prob_next_null = self.classifier.get_class1_prob(next_state_null)\n\n for i in range(self.action_dim):\n next_state_i = np.copy(next_state)\n next_state_i[:, -self.action_dim:] = self.classifier.missing_value\n next_state_i[:, -i - 1] = next_state[:, -i - 1]\n\n prob_next_i = self.classifier.get_class1_prob(obs=next_state_i)\n information_gain_per_action[:, -i - 1] = prob_next_i - prob_next_null\n\n information_gain_sum = np.sum(information_gain_per_action, axis=1, keepdims=True)\n ratio = information_gain_true / information_gain_sum\n ratio[information_gain_sum == 0] = 0\n information_gain_per_action = information_gain_per_action * ratio\n return information_gain_per_action","def specificity():\n\tatlas = 'power'\n\tproject='hcp'\n\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\"Strength of r's, i's PC & j's Q\"]\n\ttasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL',]\n\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\n\tdf = pd.DataFrame(columns = df_columns)\n\tfor task in tasks:\n\t\tprint task\n\t\t# subjects = np.array(hcp_subjects).copy()\n\t\t# subjects = list(subjects)\n\t\t# subjects = remove_missing_subjects(subjects,task,atlas)\n\t\tsubjects = np.load('/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %('hcp',task,atlas))\n\t\tstatic_results = graph_metrics(subjects,task,atlas,'fz')\n\t\tsubject_pcs = static_results['subject_pcs']\n\t\tsubject_wmds = static_results['subject_wmds']\n\t\tsubject_mods = static_results['subject_mods']\n\t\tsubject_wmds = static_results['subject_wmds']\n\t\tmatrices = static_results['matrices']\n\t\t#sum of weight changes for each node, by each node.\n\t\thub_nodes = ['WCD']\n\t\t# hub_nodes = ['PC']\n\t\tdriver_nodes_list = ['Q+','Q-']\n\t\t# driver_nodes_list = ['Q+']\n\t\tmean_pc = np.nanmean(subject_pcs,axis=0)\n\t\tmean_wmd = np.nanmean(subject_wmds,axis=0)\n\t\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\n\t\tfor i in range(subject_pcs.shape[1]):\n\t\t\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\n\t\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\n\t\tfor i in range(subject_wmds.shape[1]):\n\t\t\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\n\t\tfor hub_node in hub_nodes:\n\t\t\tif hub_node == 'PC':\n\t\t\t\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_pcs,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(project,task,atlas)))\n\t\t\t\tconnector_nodes = np.where(mod_pc_corr>0.0)[0]\n\t\t\t\tlocal_nodes = np.where(mod_pc_corr<0.0)[0]\n\t\t\telse:\n\t\t\t\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(project,task,atlas)))\n\t\t\t\tconnector_nodes = np.where(mod_wmd_corr>0.0)[0]\n\t\t\t\tlocal_nodes = np.where(mod_wmd_corr<0.0)[0]\n\t\t\tedge_thresh_val = 50.0\n\t\t\tedge_thresh = np.percentile(np.nanmean(matrices,axis=0),edge_thresh_val)\n\t\t\tpc_edge_corr[:,np.nanmean(matrices,axis=0) 1: #case of multioutput prediction\n m = np.shape(y)[0] #number of samples\n n = np.shape(y)[1] #number of output elements\n \n #calculating gradients for each layer\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\n \n if layer == len(self.architecture)-1: #identifies output layer and does output layer specific calculations\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y= y)\n da_LdZ_L = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\n delta_L = np.multiply(dCda_L,da_LdZ_L)\n self.all_data[f'dCda_{layer}'] = dCda_L\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\n self.all_data[f'delta_{layer}'] = delta_L\n else: #for other layers\n da_LdZ_l = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \n self.all_data[f'delta_{layer}'] = delta_l\n \n dCdW_l = np.outer(np.sum(self.all_data[f'A{layer-1}'],axis=0)*(1/m),self.all_data[f'delta_{layer}'])\n dCdb_l = self.all_data[f'delta_{layer}']\n\n ##saving calculated data\n self.all_data[f'dCdW{layer}'] = dCdW_l\n self.all_data[f'dCdb{layer}'] = dCdb_l\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l\n \n else: #calculations for single dataset(eg for SGD)\n m = 1\n n = len(y)\n\n ##calculating gradients for each layer\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\n \n if layer == len(self.architecture)-1:\n #dCda_L = (self.all_data[f'A{layer}'] - y)*(1/(m*n))*2\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y=y)\n da_LdZ_L = self.derivatives(self.all_data[f'Z{layer}'],activation)\n delta_L = np.multiply(dCda_L,da_LdZ_L)\n self.all_data[f'dCda_{layer}'] = dCda_L\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\n self.all_data[f'delta_{layer}'] = delta_L\n else:\n da_LdZ_l = self.derivatives(self.all_data[f'Z{layer}'],activation)\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \n self.all_data[f'delta_{layer}'] = delta_l\n\n dCdW_l = np.outer(self.all_data[f'A{layer-1}'],self.all_data[f'delta_{layer}'])\n dCdb_l = self.all_data[f'delta_{layer}']\n\n #saving data\n self.all_data[f'dCdW{layer}'] = dCdW_l\n self.all_data[f'dCdb{layer}'] = dCdb_l\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l","def _reduce(self, x, y):\n coef = self._update_parallel_coef_constraints(x)\n self.coef_ = coef.T","def mutual_information(pred, true):\n \n #for now , only for univariate forecasting. So reshapes entire batch of K timesteps into vector as if single feature\n MI = mutual_info_regression(true.detach().numpy().flatten().reshape(-1,1), pred.detach().numpy().flatten())[0]\n return torch.tensor(MI)","def computeConeActivity(Analysis, ImageData, rec_field, cpd, _meta,\n _brownian=True, glasses=False):\n Rec_Field = (rec_field[540]['fft'] / rec_field['max']) \n \n ImageData['fitLaw'] = ImageData['powerlaw'](cpd[1:])\n powerlaw = ImageData['fitLaw']\n\n if _brownian: \n temp = np.arange(1, 80)\n movement_filter = brownian_motion(cpd[1:], temp)\n powerlaw *= movement_filter\n\n # compute the diffraction limited case seperately\n diffract = {}\n diff, _x = o.diffraction(_meta['samples'], \n _meta['pupil_size'],\n 16.6, \n ref_index=1.4, \n wavelength=550.0)\n # now interpolate mtf into cpd's of analysis:\n mtf = np.interp(cpd, _x, diff)\n\n # remove zeros to avoid errors in future computations:\n ind = np.where(mtf != 0)[0]\n diffract['cpd'] = cpd[ind]\n diffract['mtf'] = mtf[ind]\n\n diffract['preCone'] = (powerlaw[ind] * \n diffract['mtf'][ind])\n diffract['retina'] = (diffract['preCone'] *\n Rec_Field[ind])\n\n if glasses:\n # if glasses on, compute effect after diffraction case\n powerlaw *= gauss(cpd[1:], 10)\n\n for key in Analysis:\n # find cone fft:\n wv = Analysis[key]['wavelength']\n Rec_Field = (rec_field[wv]['fft'] / rec_field['max'])\n\n # generate MTFs for each condition:\n intensity = traceEye(\n Analysis[key]['dist'], \n Analysis[key]['off_axis'], \n Analysis[key]['pupil_size'], \n Analysis[key]['focus'],\n Analysis[key]['wavelength'])\n psf = o.genPSF(intensity, _meta['samples'])[1]\n Analysis[key]['mtf'] = o.genMTF(psf)[ind]\n\n Analysis[key]['preCone'] = (powerlaw[ind] * \n Analysis[key]['mtf'])\n\n Analysis[key]['retina'] = (Analysis[key]['preCone'] *\n Rec_Field[ind])\n\n return Analysis, diffract","def forward(self, image1, image2, intrinsic, posepred, insmap, initialdepth=None, iters=12):\n image2_org = torch.clone(image2)\n\n image1 = 2 * image1 - 1.0\n image2 = 2 * image2 - 1.0\n\n image1 = image1.contiguous()\n image2 = image2.contiguous()\n\n hdim = self.hidden_dim\n cdim = self.context_dim\n\n # run the feature network\n fmap1, fmap2 = self.fnet([image1, image2])\n\n bz, _, featureh, featurew = fmap1.shape\n device = fmap1.device\n self.init_sampling_pts(bz, featureh, featurew, device)\n \n fmap1 = fmap1.float()\n fmap2 = fmap2.float()\n corr_fn = CorrBlock(fmap1, fmap2, intrinsic, posepred, insmap, nedges=self.nedges, maxinsnum=self.args.maxinsnum)\n\n # run the context network\n cnet = self.cnet(image1)\n net, inp = torch.split(cnet, [hdim, cdim], dim=1)\n net = torch.tanh(net)\n inp = torch.relu(inp)\n\n bz, _, h, w = image1.shape\n if initialdepth is None:\n logdepth = self.initialize_logdepth(image1)\n else:\n logdepth = F.interpolate(torch.log(torch.clamp_min(initialdepth, min=1)), [int(h / 8), int(w / 8)], mode='nearest')\n\n depth_predictions = []\n logdepth_predictions = []\n local_sample_pts2ds = []\n delta_depths = []\n outputs = dict()\n for itr in range(iters):\n corr, local_sample_pts2d = corr_fn(logdepth, sampled_rld=self.sampled_rld, pts2ddict=self.pts2ddict) # index correlation volume\n\n net, up_mask, delta_depth = self.update_block(net, inp, corr, logdepth)\n\n # F(t+1) = F(t) + \\Delta(t)\n logdepth = logdepth + delta_depth\n depth = torch.exp(logdepth)\n\n depth_up = self.upsample_flow(depth, up_mask)\n\n if itr == iters - 1:\n flowpred, img1_recon, projMimg = self.depth2rgb(depth_up, image2_org, intrinsic, posepred, insmap)\n outputs['flowpred'] = flowpred\n outputs['img1_recon'] = img1_recon\n # with torch.no_grad():\n # outputs['orgflow'] = self.depth2flow(initialdepth, projMimg)\n \n depth_predictions.append(depth_up)\n logdepth_predictions.append(F.interpolate(logdepth, [h, w], mode='bilinear', align_corners=False))\n local_sample_pts2ds.append(local_sample_pts2d)\n delta_depths.append(delta_depth)\n\n outputs['depth_predictions'] = depth_predictions\n outputs['logdepth_predictions'] = logdepth_predictions\n outputs['local_sample_pts2ds'] = local_sample_pts2ds\n outputs['delta_depths'] = delta_depths\n return outputs","def calc_perc_reducts():\n #Load RCP2.6 datq\n cubes = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')\n #Get the surface and high level SO2 emissions\n surf_cube = cubes[3][:,0]\n high_cube = cubes[1][:,0]\n cubes = iris.cube.CubeList([surf_cube,high_cube])\n\n for i in range(0,len(cubes)):\n #Add the year and month to the cube and extract for 2009 onwards\n iris.coord_categorisation.add_year(cubes[i],'time',name='year')\n iris.coord_categorisation.add_month(cubes[i],'time',name='month')\n cubes[i] = cubes[i].extract(iris.Constraint(year = lambda y: y >=2009))\n\n #Make the year-on-year reduction rates\n yoy_rates = []\n for cube in cubes:\n #Calculate the global mean timeseries\n cube.coord('latitude').guess_bounds()\n cube.coord('longitude').guess_bounds()\n area_weights = iris.analysis.cartography.area_weights(cube)\n cube_mean = cube.collapsed(['latitude','longitude'],iris.analysis.MEAN,weights=area_weights)\n\n cube_rates = np.ones((cube_mean.shape))\n #Loop over the months and calculate the changes from the previous year\n #Calculate the year on year proportional changes in the global mean\n for i in range(12,cube_mean.shape[0]):\n cube_rates[i] = cube_mean[i].data / cube_mean[(i-12)].data\n\n yoy_rates.append(cube_rates)\n\n return yoy_rates","def empirical_cor(l):\n\n global fig_dphi\n\n # first clean los\n maps_temp = np.matrix.copy(maps[:,:,l]) - np.matrix.copy(models[:,:,l])\n\n # no estimation on the ref image set to zero \n if np.nansum(maps[:,:,l]) != 0:\n\n maxlos,minlos=np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],float(arguments[\"--perc_los\"])),np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],100-float(arguments[\"--perc_los\"]))\n logger.debug('Set Max-Min LOS for empirical estimation: {0}-{1}'.format(maxlos,minlos))\n kk = np.nonzero(np.logical_or(maps_temp==0.,np.logical_or((maps_temp>maxlos),(maps_tempmintopo,\n np.logical_and(mask_flat>float(arguments[\"--threshold_mask\"]),\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(~np.isnan(rmsmap),\n np.logical_and(~np.isnan(elev),\n np.logical_and(rmsmap1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>ibeg_emp,\n np.logical_and(pix_azjbeg_emp,\n np.logical_and(pix_rg0.,\n ))))))))\n ))))))\n\n # extract coordinates for estimation\n temp = np.array(index).T\n x = temp[:,0]; y = temp[:,1]\n # clean maps\n los_clean = maps_temp[index].flatten()\n topo_clean = elev[index].flatten()\n rms_clean = rmsmap[index].flatten()\n \n logger.debug('Number of points for empirical estimation: {}'.format(len(los_clean)))\n if len(los_clean) < 1:\n logger.critical('No points left for empirical estimation. Exit!')\n logger.critical('threshold RMS: {0}, threshold Mask: {1}, Min-Max LOS: {2}-{3}, Min-Max topo: {4}-{5}, lines: {6}-{7}, \\\n cols: {8}- {9}'.format(float(arguments[\"--threshold_rms\"]),float(arguments[\"--threshold_mask\"]),minlos,maxlos,mintopo,maxtopo,ibeg_emp,iend_emp,jbeg_emp,jend_emp))\n sys.exit()\n\n # print itemp, iend_emp\n if flat>5 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\n logger.warning('Image too short in comparison to master, set flat to 5')\n temp_flat=5\n else:\n temp_flat=flat\n\n if ivar>0 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\n logger.warning('Image too short in comparison to master, set ivar to 0')\n ivar_temp=0\n nfit_temp=0\n else:\n ivar_temp=ivar\n nfit_temp=nfit\n\n # call ramp estim\n los = as_strided(maps[:,:,l]).flatten()\n samp = int(arguments[\"--emp_sampling\"])\n\n map_ramp, map_flata, map_topo, rmsi = estim_ramp(los,los_clean[::samp],topo_clean[::samp],x[::samp],\\\n y[::samp],temp_flat,rms_clean[::samp],nfit_temp, ivar_temp, l, ax_dphi)\n\n if (lin_start is not None) and (lin_end is not None):\n # try:\n indexref = np.nonzero(np.logical_and(elevmintopo,\n np.logical_and(mask_flat>float(arguments[\"--threshold_mask\"]),\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(~np.isnan(rmsmap),\n np.logical_and(~np.isnan(elev),\n np.logical_and(rmsmap1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>lin_start,\n np.logical_and(pix_azcol_start,\n np.logical_and(pix_rg0.,\n ))))))))))))\n ))\n \n if len(indexref[0]) == 0:\n logger.warning('Ref zone is empty! Re-define --ref_zone argument. Exit!')\n sys.exit()\n\n ## Set data minus temporal model to zero in the ref area\n zone = as_strided(map_flata[:,:] - models[:,:,l])\n los_ref2 = zone[indexref].flatten()\n rms_ref = rmsmap[indexref].flatten()\n amp_ref = 1./rms_ref\n amp_ref = amp_ref/np.nanmax(amp_ref)\n # weigth avera of the phase\n cst = np.nansum(los_ref2*amp_ref) / np.nansum(amp_ref)\n logger.info('Re-estimation of a constant within lines {0}-{1} and cols {2}-{3}'.format(lin_start,lin_end,col_start,col_end))\n logger.info('Average phase within ref area: {0}:'.format(cst))\n if np.isnan(cst):\n cst = 0.\n map_ramp, map_flata = map_ramp + cst, map_flata - cst\n del zone\n \n else:\n map_flata = np.copy(maps[:,:,l])\n map_ramp, map_topo = np.zeros(np.shape(map_flata)), np.zeros(np.shape(map_flata))\n rmsi = 1\n\n # set ramp to NaN to have ramp of the size of the images\n kk = np.nonzero(np.isnan(map_flata))\n ramp = as_strided(map_ramp)\n ramp[kk] = float('NaN')\n topo = as_strided(map_topo)\n topo[kk] = float('NaN')\n del ramp, topo\n \n return map_ramp, map_flata, map_topo, rmsi","def calculate_information_criterion(R, u_t, R_test, u_t_test, inverse_transform, inverse_transform_test, algo, x_nodes):\n model_list = generate_models(R, u_t, inverse_transform, algo) # iterates hyperparameters to generate models\n evidence_list = calculate_bic(R_test, u_t_test, inverse_transform_test, model_list, x_nodes)\n return evidence_list, model_list","def calculate_all_metrcis(self):\n self.calculate_gc_metrcis()\n self.calculate_sam_metrics()\n self.calculate_classification_metrics()\n self.calculate_losses()","def dataModel():\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\n\n image_data = fits.getdata('6gev_image.fits')\n filename = get_pkg_data_filename('6gev_image.fits')\n hdu = fits.open(filename)[0]\n wcs = WCS(hdu.header)\n\n #Given the results of the fit, calculate the model\n modelData001 = np.zeros(srcmap001[0].shape)\n modelData03 = np.zeros(srcmap03[0].shape)\n\n file = open('plotsData/fitResults001.pk1','rb')\n fit001 = pickle.load(file)\n file.close()\n\n file = open('plotsData/fitResults03.pk1','rb')\n fit03 = pickle.load(file)\n file.close()\n\n\n for source in fit001:\n the_index = srcmap001.index_of(source)\n\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\n for source in fit03:\n the_index = srcmap03.index_of(source)\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\n\n fig = plt.figure(figsize=[12, 4.5])\n\n vmin = 0\n vmax = 70.0\n cbStep = 10.0\n ax = fig.add_subplot(121, projection=wcs)\n ax=plt.gca()\n ax.tick_params(direction='in')\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\n ax.add_patch(c)\n mappable=plt.imshow((image_data),cmap='inferno',origin='lower',norm=colors.PowerNorm(gamma=0.6),vmin=vmin, vmax=vmax, interpolation='gaussian')#\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('Data ($>6$ GeV)')\n cb = plt.colorbar(mappable, label='Counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb.ax.tick_params(width=0)\n\n\n ax2=fig.add_subplot(122, projection=wcs)\n ax2 = plt.gca()\n\n sources = []\n sources.append({\n 'Name':'3FGL J1745.3-2903c',\n 'RA':266.3434922,\n 'DEC':-29.06274323,\n 'color':'xkcd:bright light blue'})\n\n sources.append({\n 'Name':'1FIG J1748.2-2816',\n 'RA':267.1000722,\n 'DEC':-28.27707114,\n 'color':'xkcd:fire engine red'\n })\n\n sources.append({\n 'Name':'1FIG J1746.4-2843',\n 'RA':266.5942898,\n 'DEC':-28.86244442,\n 'color':'xkcd:fluorescent green'\n })\n\n sources.append({\n 'Name':'Galactic Center',\n 'RA':266.417,\n 'DEC':-29.0079,\n 'color':'black'\n })\n\n #Add source names:\n for source in sources:\n l, b = ra_dec_to_l_b(source['RA'], source['DEC'])\n ax2.scatter(l, b, color=source['color'],marker='x',s=45.0, transform=ax2.get_transform('galactic'), label=source['Name'])\n\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\n ax2.add_patch(c2)\n mappable2 = plt.imshow((np.sum(modelData03,axis=0)), cmap='inferno',norm=colors.PowerNorm(gamma=0.6),origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('Model ($>6$ GeV)')\n cb2 = plt.colorbar(mappable2, label='Counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb2.ax.tick_params(width=0)\n leg = plt.legend(loc=1,frameon=True)\n leg.get_frame().set_alpha(0.5)\n leg.get_frame().set_edgecolor('white')\n text1 = leg.get_texts()\n for text in text1:\n text.set_color('black')\n\n fig.tight_layout()\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\n plt.show()\n #plt.savefig('plots/dataModelComparison.pdf',bbox_inches='tight')","def summary(self):\n for i,layer in enumerate(self.chain):\n x = Input([2])\n y = layer.forward(x)\n Model(x,y,name=f'layer_{i}_summary').summary()","def calculate_correlation(data):\n pass","def constant_2015():\n\n #Load the CMIP6 historical\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\n #Get low and high level emissions just in the last year (2014)\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\n final_cubes = iris.cube.CubeList()\n for cube in cubes:\n final_cube = cube[-12:]\n final_cubes.append(final_cube)\n \n #Set the year-on-year proportional reductions to be nothing\n yoy_rates = calc_perc_reducts()\n yoy_rates = np.array(yoy_rates)\n yoy_rates = np.ones_like(yoy_rates)\n\n #Create coordinates for new nc file between 2014 and 2100\n lat_coord = cubes[0].coord('latitude')\n lon_coord = cubes[0].coord('longitude')\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\n\n #Create the cube date\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n #Set first year equal to 2014 in CMIP6 historical\n cube_data_surf[:12,...] = final_cubes[0].data\n cube_data_high[:12,...] = final_cubes[1].data\n #Apply equal emissions in all other years too\n for i in range(12,cube_data_surf.shape[0]):\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\n #Make the output cubes\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\n\n fut_cube_high.var_name = 'field569_1'\n fut_cube_high.units='kg/m2/s'\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\n fut_cube_surf.var_name = 'field569'\n fut_cube_surf.units='kg/m2/s'\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\n\n #Load the DMS cube from standard RCP2.6\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\n\n dms_cube.var_name = 'field570'\n dms_cube.attributes.pop('name')\n dms_cube.coord('time').var_name = 'time'\n dms_cube.coord('time').long_name = 'time'\n\n fut_cube_high = fut_cube_high[:-2]\n fut_cube_surf = fut_cube_surf[:-2]\n\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\n\n #Save the final cubes as netcdf (cutting them to be the same length)\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \"SO2DMS_const2014.nc\")\n os.system('ncatted -O -a calendar,time,m,c,\"360_day\" '+data_dir+ \"SO2DMS_const2014.nc\")\n\n return","def calculate_correlations(model_metric = \"MSE\", correlation_type = \"Pearsons\", save = True):\n \n if model_metric == \"MSE\":\n augmented_results = 'augmented_mse.csv'\n else:\n augmented_results = 'augmented_f1_score.csv'\n \n main_path = Path(os.path.dirname(__file__)).parent\n metadata_path = r\"visualize_results\"\n metadata = pd.read_csv(os.path.join(main_path, metadata_path, augmented_results))\n \n metadata['DateTime'] = pd.to_datetime(metadata['DateTime'], dayfirst = True)\n \n cleanup_nums = {\"Day_Night\": {\"day\": 0, \"night\": 1}}\n metadata = metadata.replace(cleanup_nums)\n \n tested_columns = [model_metric,\"Temperature\", \"Humidity\", \"Wind Speed\", \"Wind Direction\", \"Precipitation\",\"Activity\", \"Day_Night\", \"Hour\"] \n \n all_correlations = []\n all_p_values = []\n for model in metadata[\"model\"].unique():\n \n metadata_smaller = metadata[(metadata[\"model\"]== model)].copy()\n metadata_smaller = metadata_smaller[tested_columns]\n metadata_smaller = metadata_smaller.reset_index(drop=True)\n \n print(f\"For Model: {model}\")\n corr_curr_model = []\n p_value_curr_model =[]\n for column in metadata_smaller.columns:\n \n if correlation_type == \"Pearsons\":\n cor,p = stats.pearsonr(metadata_smaller[column], metadata_smaller[model_metric])\n else:\n cor,p = distcorr(metadata_smaller[column], metadata_smaller[model_metric],nruns = 5000)\n \n corr_curr_model.append(cor)\n p_value_curr_model.append(p)\n \n print(f\"between {model_metric} and {column} = R: {np.abs(cor)}, p-val: {p}\")\n \n corr_curr_model.insert(0,model)\n corr_curr_model.insert(0,model_metric)\n corr_curr_model.insert(0,correlation_type)\n \n p_value_curr_model.insert(0,model)\n p_value_curr_model.insert(0,model_metric)\n p_value_curr_model.insert(0,correlation_type)\n \n print(\"---------------\")\n all_correlations.append(corr_curr_model)\n all_p_values.append(p_value_curr_model)\n \n all_correlations_df = pd.DataFrame(all_correlations,\n columns = [\"Correlation\", \"Metric\", \"Model\"] + tested_columns)\n \n all_p_values_df = pd.DataFrame(all_p_values,\n columns = [\"Correlation\", \"Metric\", \"Model\"] + tested_columns)\n \n if save:\n all_correlations_df.to_csv(os.path.join(\"analysis_results\", f\"correlation_R_{correlation_type}_{model_metric}.csv\"), index=False)\n all_p_values_df.to_csv(os.path.join(\"analysis_results\", f\"correlation_Pvalue_{correlation_type}_{model_metric}.csv\"), index=False)\n \n return all_correlations_df","def filter_and_correct_expression_and_image_features(tissue, model, aggregation, patch_size, M, k, pc_correction=False, tf_correction=False):\n\n\n\n\n # Filter expression\n Y, X, dIDs, tIDs, tfs, ths, t_idx = extract_final_layer_data(tissue, model, aggregation, patch_size)\n filt_X, filt_tIDs, final_exp_idx = filter_expression(X, tIDs, M, k)\n\n\n\n if pc_correction:\n print ('Correcting with {} expression PCs'.format(pc_correction))\n pca = PCA(n_components=pc_correction)\n\n\n pca_predictors = pca.fit_transform(filt_X)\n\n # Correct Y\n lr = LinearRegression()\n lr.fit(pca_predictors, Y)\n predicted_Y = lr.predict(pca_predictors)\n corrected_Y = Y - predicted_Y\n\n # Correct X\n projected_filt_X = np.dot(pca_predictors,pca.components_)\n corrected_filt_X = filt_X - projected_filt_X\n\n # Set as return variables\n final_X = corrected_filt_X\n final_Y = corrected_Y\n\n elif tf_correction:\n print('Correcting with all technical factors')\n tf_Y = Y[t_idx,:]\n tf_filt_X = filt_X[t_idx,:]\n\n tfs[list(ths).index('SMTSISCH')] = np.log2(tfs[list(ths).index('SMTSISCH')] + 1)\n tf_predictors = tfs\n\n #Correct Y\n lr_Y = LinearRegression()\n lr_Y.fit(tf_predictors, tf_Y)\n tf_Y_predicted = lr_Y.predict(tf_predictors)\n corrected_tf_Y = tf_Y - tf_Y_predicted\n\n #Correct X\n lr_X = LinearRegression()\n lr_X.fit(tf_predictors, tf_filt_X)\n tf_filt_X_predicted = lr_X.predict(tf_predictors)\n corrected_tf_filt_X = tf_filt_X - tf_filt_X_predicted\n\n # Set as return variables\n final_X = corrected_tf_filt_X\n final_Y = corrected_tf_Y\n else:\n # Set unmodified values as return variables\n final_X = filt_X\n final_Y = Y\n\n return final_Y, final_X, dIDs, filt_tIDs, tfs, ths, t_idx","def pan_corr(file):\n\n # # infile = 'd:\\\\Projekti\\\\Satelit\\\\CO\\\\Razpis\\\\Flat field images_new2020\\\\flatfield\\\\NHDBflat_1D'\n # # infile = 'd:\\Projekti\\Satelit\\CO\\Razpis\\_POSNETKI\\Jure_naloga_banje_raw_pyt\\\\NHDRGoreMorje_3D'\n #\n # # in_path = 'd:\\Projekti\\Satelit\\CO\\Razpis\\Flat field images_new2020\\\\20201028 Vignetting\\\\flatfield\\\\'\n # # in_pan_ref_file = 'NHDPflat_3D_py.tif'\n # in_path = 'd:\\Projekti\\Satelit\\CO\\Razpis\\_POSNETKI\\Peking_PAN\\\\'\n # in_pan_ref_file = 'NHDPfoc_swp6_1D_py.tif'\n # in_ref = in_path + in_pan_ref_file\n #\n # inreffil = gdal.Open(in_ref)\n # image_ref = inreffil.ReadAsArray()\n # # size_ref = image_ref.shape\n # # pix_count = size_ref[0]*size_ref[1]\n #\n # image_ref = image_ref[800:930, 1420:1640]\n # size_ref = image_ref.shape\n # pix_count = size_ref[0] * size_ref[1]\n #\n # g1 = 0.\n # g2 = 0.\n # r1 = 0.\n # b1 = 0.\n #\n # for i in range(size_ref[0]):\n # for j in range(size_ref[1]):\n # if (i % 2) == 0 and (j % 2) == 0: g1 = g1 + image_ref[i, j]\n # if (i % 2) == 1 and (j % 2) == 1: g2 = g2 + image_ref[i, j]\n # if (i % 2) == 0 and (j % 2) == 1: r1 = r1 + image_ref[i, j]\n # if (i % 2) == 1 and (j % 2) == 0: b1 = b1 + image_ref[i, j]\n #\n # g1_avg = g1 / pix_count * 4\n # g2_avg = g2 / pix_count * 4\n # r1_avg = r1 / pix_count * 4\n # b1_avg = b1 / pix_count * 4\n #\n # raz_g1 = 1\n # raz_g2 = g1_avg/g2_avg\n # raz_r1 = g1_avg/r1_avg\n # raz_b1 = g1_avg/b1_avg\n #\n # avg = (g1+g2+r1+b1)/pix_count\n #\n # print(g1_avg, g2_avg, r1_avg, b1_avg, avg)\n\n raz_g1 = 1\n raz_g2 = 1.0245196396115988\n raz_r1 = 1.0131841989689434\n raz_b1 = 1.0517113199247086\n\n print('razmerje:', raz_g1, raz_g2, raz_r1, raz_b1)\n\n # in_path = 'd:\\Projekti\\Satelit\\CO\\Razpis\\_POSNETKI\\Peking_PAN\\\\'\n # in_pan_ref_file = 'NHDPfoc_swp6_4D_py.tif'\n # in_path = 'd:\\Projekti\\Satelit\\CO\\Razpis\\Flat field images_new2020\\\\20201028 Vignetting\\\\flatfield\\\\'\n # in_pan_ref_file = 'NHDPflat_3D_py.tif'\n\n # in_path = 'd:\\Projekti\\Satelit\\CO\\Razpis\\_POSNETKI\\Slo_PAN\\_26_30\\\\'\n # in_pan_ref_file = [filename for filename in os.listdir(in_path) if filename.lower().startswith(\"nhd\") and filename.lower().endswith(\"tif\")]\n\n \n\n \n\n # print('image', i)\n in_ref=file\n inreffil = gdal.Open(in_ref)\n image_ref = inreffil.ReadAsArray()\n size_ref = image_ref.shape\n # pix_count = size_ref[0] * size_ref[1]\n # pix_count = np.count_nonzero(image_ref)\n # pix_count = 3664*650\n\n # g1 = 0.\n # g2 = 0.\n # r1 = 0.\n # b1 = 0.\n #\n # for i in range(size_ref[0]):\n # for j in range(size_ref[1]):\n # if (i % 2) == 0 and (j % 2) == 0: g1 = g1 + image_ref[i, j]\n # if (i % 2) == 1 and (j % 2) == 1: g2 = g2 + image_ref[i, j]\n # if (i % 2) == 0 and (j % 2) == 1: r1 = r1 + image_ref[i, j]\n # if (i % 2) == 1 and (j % 2) == 0: b1 = b1 + image_ref[i, j]\n #\n # g1_avg = g1 / pix_count * 4\n # g2_avg = g2 / pix_count * 4\n # r1_avg = r1 / pix_count * 4\n # b1_avg = b1 / pix_count * 4\n #\n # avg = (g1 + g2 + r1 + b1) / pix_count\n #\n # print(g1_avg, g2_avg, r1_avg, b1_avg, avg)\n\n # popravek\n im_p_pop = np.zeros((size_ref[0], size_ref[1]), np.uint16)\n\n\n for i in range(size_ref[0]):\n for j in range(size_ref[1]):\n if (i % 2) == 0 and (j % 2) == 0 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_g1\n if (i % 2) == 1 and (j % 2) == 1 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_g2\n if (i % 2) == 0 and (j % 2) == 1 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_r1\n if (i % 2) == 1 and (j % 2) == 0 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_b1\n \n _,_,_,_,P=return_flatfield_set_path(2)\n P_flat=gdal_array.LoadFile(P)\n \n # im_p_pop=simple_flatfield_corr(P_flat, im_p_pop, 2, 1) \n \n # outout\n \n im_p_pop=BLUE_simple_flatfield_corr(P_flat, im_p_pop)\n \n out=os.path.abspath(file)+\"/corr/\"+os.path.basename(file)[:-4] + \"_pop_flat_corr.tif\"\n\n \n # out = in_ref[:-4] + \"_pop_flat_corr.tif\"\n\n driver = gdal.GetDriverByName('GTiff')\n\n # outRaster = driver.Create(out, size[1], size[0], 3, gdal.GDT_UInt16)\n outRaster = driver.Create(out, size_ref[1], size_ref[0], 1, gdal.GDT_UInt16)\n\n outband = outRaster.GetRasterBand(1)\n outband.WriteArray(im_p_pop)\n outband.FlushCache()","def compute(self,input):\n\n for layer in self.layers:\n input = layer.compute(input)\n return input","def update_variables(self):\n self.dl21 = self.l21-self.l11; self.dl22 = self.l22-self.l12; self.dl23 = self.l23-self.l13;\n self.kappa1, self.phi1, self.seg_len1 = self.configuration_space(self.l11, self.l12, self.l13, self.d, self.n)\n self.kappa2, self.phi2, self.seg_len2 = self.configuration_space(self.dl21, self.dl22, self.dl23, self.d, self.n)\n # aquire transformation matrices and tips for segment 1 and 2\n self.T01_bishop = self.transformation_matrix_bishop(self.kappa1, self.phi1, self.seg_len1)\n self.T12_bishop = self.transformation_matrix_bishop(self.kappa2, self.phi2, self.seg_len2)\n self.T02_bishop = np.matmul(self.T01_bishop, self.T12_bishop)\n self.T01_frenet = self.transformation_matrix_frenet(self.kappa1, self.phi1, self.seg_len1)\n self.T12_frenet = self.transformation_matrix_frenet(self.kappa2, self.phi2, self.seg_len2)\n self.T02_frenet = np.matmul(self.T01_frenet, self.T12_frenet)\n self.tip_vec1 = np.matmul(self.T01_bishop, self.base)[0:3]\n self.tip_vec2 = np.matmul(self.T02_bishop, self.base)[0:3]\n # Frenet frames\n self.normal_vec_frenet1 = self.T01_frenet[0:3, 0]\n self.binormal_vec_frenet1 = self.T01_frenet[0:3, 1]\n self.tangent_vec_frenet1 = self.T01_frenet[0:3, 2]\n self.normal_vec_frenet2 = self.T02_frenet[0:3, 0]\n self.binormal_vec_frenet2 = self.T02_frenet[0:3, 1]\n self.tangent_vec_frenet2 = self.T02_frenet[0:3, 2]\n # Bishop frames\n self.normal_vec_bishop1 = self.T01_bishop[0:3, 0]\n self.binormal_vec_bishop1 = self.T01_bishop[0:3, 1]\n self.tangent_vec_bishop1 = self.T01_bishop[0:3, 2]\n self.normal_vec_bishop2 = self.T02_bishop[0:3, 0]\n self.binormal_vec_bishop2 = self.T02_bishop[0:3, 1]\n self.tangent_vec_bishop2 = self.T02_bishop[0:3, 2]","def image_forward(self, general_x, general_y, general_z):\n disti_p = F.pairwise_distance(general_y, general_z, 2)\n disti_n1 = F.pairwise_distance(general_y, general_x, 2)\n disti_n2 = F.pairwise_distance(general_z, general_x, 2)\n target = torch.FloatTensor(disti_p.size()).fill_(1)\n loss_sim_i1 = self.loss_sim_i(disti_p, disti_n1, target)\n loss_sim_i2 = self.loss_sim_i(disti_p, disti_n2, target)\n loss_sim_i = (loss_sim_i1 + loss_sim_i2) / 2.0\n return loss_sim_i","def _calculate_information_gain(self, cur_state, next_state, next_label):\n n = len(cur_state)\n information_gain_per_action = np.zeros((n, self.action_dim))\n prob_prev = self.classifier.get_class1_prob(obs=cur_state)\n\n for i in range(self.action_dim):\n obs_i = np.copy(next_state)\n obs_i[:, -self.action_dim:] = cur_state[:, -self.action_dim:]\n obs_i[:, - i - 1] = next_state[:, -i - 1]\n\n prob_i = self.classifier.get_class1_prob(obs=obs_i)\n class_1_gain = (prob_i - prob_prev) * next_label[:, 0]\n class_0_gain = (prob_i - prob_prev) * (1 - next_label)[:, 0]\n\n if self.positive_only:\n class_1_gain[class_1_gain < 0] = 0\n class_0_gain[class_0_gain < 0] = 0\n else:\n class_0_gain = - class_0_gain\n\n information_gain_per_action[:, - i - 1] = (class_1_gain + class_0_gain)\n\n return information_gain_per_action","def extract(self,image_path):#image_path\r\n\r\n img = caffe.io.load_image(image_path)\r\n \r\n #image1=cv2.imread(caffe_root + 'examples/images/cat.jpg') \r\n #img=cv2.cvtColor(image1,cv2.COLOR_BGR2RGB) \r\n #img=img/255. \r\n \r\n\r\n transformed_image = self.transformer.preprocess('data', img)\r\n self.net.blobs['data'].data[...] = transformed_image\r\n ft = self.net.forward()\r\n ft = np.squeeze(ft['pool5/7x7_s1'])\r\n ft = ft / LA.norm(ft)\r\n return ft","def run(self):\n #self.source_fixed = center_of_mass(self.source_mesh.vs)\n #self.destination_fixed = center_of_mass(self.destination_mesh.vs)\n\n source_high_curvature = get_mesh_of_high_curvature(self.source_mesh)\n destination_high_curvature = get_mesh_of_high_curvature(self.destination_mesh)\n\n self.matrix, error = icp(source_high_curvature.vs, \n destination_high_curvature.vs, \n self.source_fixed, \n self.destination_fixed,\n 300,\n verbose = self.verbose)\n\n self.inverse = np.linalg.inv(self.matrix)\n self.global_confidence = 1 - error\n print self.global_confidence","def computeIntercepts():\n pass","def get_cost_updates(self, contraction_level, learning_rate):\r\n\r\n y = self.get_hidden_values(self.x)\r\n z = self.get_reconstructed_input(y)\r\n J = self.get_jacobian(y, self.W)\r\n # note : we sum over the size of a datapoint; if we are using\r\n # minibatches, L will be a vector, with one entry per\r\n # example in minibatch\r\n self.L_rec = - T.sum(self.x * T.log(z) +\r\n (1 - self.x) * T.log(1 - z),\r\n axis=1)\r\n\r\n # Compute the jacobian and average over the number of samples/minibatch\r\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\r\n\r\n # note : L is now a vector, where each element is the\r\n # cross-entropy cost of the reconstruction of the\r\n # corresponding example of the minibatch. We need to\r\n # compute the average of all these to get the cost of\r\n # the minibatch\r\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\r\n\r\n # compute the gradients of the cost of the `cA` with respect\r\n # to its parameters\r\n gparams = T.grad(cost, self.params)\r\n # generate the list of updates\r\n updates = []\r\n for param, gparam in zip(self.params, gparams):\r\n updates.append((param, param - learning_rate * gparam))\r\n\r\n return (cost, updates)","def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\n shape = tuple([None]+list(input_shape[1:]))\n print(shape)\n l_in = lasagne.layers.InputLayer(shape=shape)\n\n print(\"Input shape: \",lasagne.layers.get_output_shape(l_in))\n\n # print(shaped_units)\n # shaped_units = shaped_units[0]\n shaped_units = 2800\n\n # print(shape)\n\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\n l_in, \n num_filters=8,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n print(\"Conv 2D shape: \",lasagne.layers.get_output_shape(l_conv2D_1))\n\n l_reshape_1 = lasagne.layers.ReshapeLayer(\n l_conv2D_1,\n shape=(([0], -1))\n )\n\n print(\"Reshape 1 shape: \", lasagne.layers.get_output_shape(l_reshape_1))\n\n l_hidden_1 = lasagne.layers.DenseLayer(\n l_reshape_1,\n num_units= num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 1 shape: \", lasagne.layers.get_output_shape(l_hidden_1))\n\n l_code_layer = lasagne.layers.DenseLayer(\n l_hidden_1,\n num_units=num_code_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Code layer shape: \",lasagne.layers.get_output_shape(l_code_layer))\n\n l_hidden_2 = lasagne.layers.DenseLayer(\n l_code_layer,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 2 shape: \",lasagne.layers.get_output_shape(l_hidden_2))\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_hidden_2,\n num_units=shaped_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 3 shape: \",lasagne.layers.get_output_shape(l_hidden_3))\n\n l_reshape_2 = lasagne.layers.ReshapeLayer(\n l_hidden_3,\n shape=(([0],8,7,50))\n )\n\n print(\"Reshape 2 shape: \",lasagne.layers.get_output_shape(l_reshape_2))\n\n l_out = lasagne.layers.Conv2DLayer(\n l_reshape_2, \n num_filters=1,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n # print(\"Deconv shape: \",lasagne.layers.get_output_shape(l_deconv2D_1))\n\n print(\"Output shape: \",lasagne.layers.get_output_shape(l_out))\n\n return l_out","def loss(self, z1, z2_con_z1, z3, z1_rec, z2_con_z1_rec, z3_rec):\n pass","def get_cost_updates(self, contraction_level, learning_rate):\n self.n_batchsize = 20\n y = self.get_hidden_values(self.x)\n z = self.get_reconstructed_input(y)\n J = self.get_jacobian(y, self.W)\n # note : we sum over the size of a datapoint; if we are using\n # minibatches, L will be a vector, with one entry per\n # example in minibatch\n self.L_rec = - T.sum(self.x * T.log(z) +\n (1 - self.x) * T.log(1 - z),\n axis=1)\n\n # Compute the jacobian and average over the number of samples/minibatch\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\n\n # note : L is now a vector, where each element is the\n # cross-entropy cost of the reconstruction of the\n # corresponding example of the minibatch. We need to\n # compute the average of all these to get the cost of\n # the minibatch\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\n\n # compute the gradients of the cost of the `cA` with respect\n # to its parameters\n gparams = T.grad(cost, self.params)\n # generate the list of updates\n updates = []\n for param, gparam in zip(self.params, gparams):\n updates.append((param, param - learning_rate * gparam))\n\n return (cost, updates)","def compute_metrics(mat,language='English',method ='dimensional',output='data_frame'):\n language = language.lower()\n method = method.lower()\n if language == 'english':\n if method == 'dimensional':\n if output == 'data_frame':\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\n return(mat)\n elif output == 'array':\n out_dict = {}\n out_dict['PosVal'] = mat[:,:,0]\n out_dict['NegVal'] = mat[:,:,1]\n out_dict['Arousal'] = mat[:,:,2]\n out_dict['Dominance'] = mat[:,:,3]\n out_dict['PosCount'] = mat[:,:,4]\n out_dict['DetectCount'] = mat[:,:,5]\n out_dict['TokenCount'] = mat[:,:,6]\n out_dict['ValSq'] = mat[:,:,7]\n\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\n # Mean Values:\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DetectCount'])\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\n # Percentages:\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\")\n elif method == 'discrete':\n if output == 'data_frame':\n mat['function_Percent'] = mat.function / mat.TokenCount\n mat['pronoun_Percent'] = mat.pronoun / mat.TokenCount\n mat['ppron_Percent'] = mat.ppron / mat.TokenCount\n mat['i_Percent'] = mat.i / mat.TokenCount\n mat['we_Percent'] = mat.we / mat.TokenCount\n mat['you_Percent'] = mat.you / mat.TokenCount\n mat['shehe_Percent'] = mat.shehe / mat.TokenCount\n mat['they_Percent'] = mat.they / mat.TokenCount\n mat['ipron_Percent'] = mat.ipron / mat.TokenCount\n mat['article_Percent'] = mat.article / mat.TokenCount\n mat['prep_Percent'] = mat.prep / mat.TokenCount\n mat['auxverb_Percent'] = mat.auxverb / mat.TokenCount\n mat['adverb_Percent'] = mat.adverb / mat.TokenCount\n mat['conj_Percent'] = mat.conj / mat.TokenCount\n mat['negate_Percent'] = mat.negate / mat.TokenCount\n mat['verb_Percent'] = mat.verb / mat.TokenCount\n mat['adj_Percent'] = mat.adj / mat.TokenCount\n mat['compare_Percent'] = mat.compare / mat.TokenCount\n mat['interrog_Percent'] = mat.interrog / mat.TokenCount\n mat['number_Percent'] = mat.number / mat.TokenCount\n mat['quant_Percent'] = mat.quant / mat.TokenCount\n mat['affect_Percent'] = mat.affect / mat.TokenCount\n mat['posemo_Percent'] = mat.posemo / mat.TokenCount\n mat['negemo_Percent'] = mat.negemo / mat.TokenCount\n mat['anx_Percent'] = mat.anx / mat.TokenCount\n mat['anger_Percent'] = mat.anger / mat.TokenCount\n mat['sad_Percent'] = mat.sad / mat.TokenCount\n mat['social_Percent'] = mat.social / mat.TokenCount\n mat['family_Percent'] = mat.family / mat.TokenCount\n mat['friend_Percent'] = mat.friend / mat.TokenCount\n mat['female_Percent'] = mat.female / mat.TokenCount\n mat['male_Percent'] = mat.male / mat.TokenCount\n mat['cogproc_Percent'] = mat.cogproc / mat.TokenCount\n mat['insight_Percent'] = mat.insight / mat.TokenCount\n mat['cause_Percent'] = mat.cause / mat.TokenCount\n mat['discrep_Percent'] = mat.discrep / mat.TokenCount\n mat['tentat_Percent'] = mat.tentat / mat.TokenCount\n mat['certain_Percent'] = mat.certain / mat.TokenCount\n mat['differ_Percent'] = mat.differ / mat.TokenCount\n mat['percept_Percent'] = mat.percept / mat.TokenCount\n mat['see_Percent'] = mat.see / mat.TokenCount\n mat['hear_Percent'] = mat.hear / mat.TokenCount\n mat['feel_Percent'] = mat.feel / mat.TokenCount\n mat['bio_Percent'] = mat.bio / mat.TokenCount\n mat['body_Percent'] = mat.body / mat.TokenCount\n mat['health_Percent'] = mat.health / mat.TokenCount\n mat['sexual_Percent'] = mat.sexual / mat.TokenCount\n mat['ingest_Percent'] = mat.ingest / mat.TokenCount\n mat['drives_Percent'] = mat.drives / mat.TokenCount\n mat['affiliation_Percent'] = mat.affiliation / mat.TokenCount\n mat['achieve_Percent'] = mat.achieve / mat.TokenCount\n mat['power_Percent'] = mat.power / mat.TokenCount\n mat['reward_Percent'] = mat.reward / mat.TokenCount\n mat['risk_Percent'] = mat.risk / mat.TokenCount\n mat['focuspast_Percent'] = mat.focuspast / mat.TokenCount\n mat['focuspresent_Percent'] = mat.focuspresent / mat.TokenCount\n mat['focusfuture_Percent'] = mat.focusfuture / mat.TokenCount\n mat['relativ_Percent'] = mat.relativ / mat.TokenCount\n mat['motion_Percent'] = mat.motion / mat.TokenCount\n mat['space_Percent'] = mat.space / mat.TokenCount\n mat['time_Percent'] = mat.time / mat.TokenCount\n mat['work_Percent'] = mat.work / mat.TokenCount\n mat['leisure_Percent'] = mat.leisure / mat.TokenCount\n mat['home_Percent'] = mat.home / mat.TokenCount\n mat['money_Percent'] = mat.money / mat.TokenCount\n mat['relig_Percent'] = mat.relig / mat.TokenCount\n mat['death_Percent'] = mat.death / mat.TokenCount\n mat['informal_Percent'] = mat.informal / mat.TokenCount\n mat['swear_Percent'] = mat.swear / mat.TokenCount\n mat['netspeak_Percent'] = mat.netspeak / mat.TokenCount\n mat['assent_Percent'] = mat.assent / mat.TokenCount\n mat['nonflu_Percent'] = mat.nonflu / mat.TokenCount\n mat['filler_Percent'] = mat.filler / mat.TokenCount\n mat['Detect_Percent'] = mat.DetectCount / mat.TokenCount\n return(mat)\n elif output == 'array':\n out_dict = {}\n out_dict['Affect'] = mat[:,:,21]\n out_dict['Posemo'] = mat[:,:,22]\n out_dict['Negemo'] = mat[:,:,23]\n out_dict['Anx'] = mat[:,:,24]\n out_dict['Anger'] = mat[:,:,25]\n out_dict['Sad'] = mat[:,:,26]\n out_dict['Function'] = mat[:,:,0]\n out_dict['CogProc'] = mat[:,:,32]\n out_dict['DetectCount'] = mat[:,:,-2]\n out_dict['TokenCount'] = mat[:,:,-1]\n\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\n\n\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\") \n else:\n print(\"Error: Method not found!\")\n elif language == 'german':\n if method == 'dimensional':\n if output == 'data_frame':\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\n mat['MeanPotency'] = mat['Potency'] / mat['DetectCount']\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\n return(mat)\n elif output == 'array':\n out_dict = {}\n out_dict['PosVal'] = mat[:,:,0]\n out_dict['NegVal'] = mat[:,:,1]\n out_dict['Arousal'] = mat[:,:,2]\n out_dict['Dominance'] = mat[:,:,3]\n out_dict['PosCount'] = mat[:,:,4]\n out_dict['DetectCount'] = mat[:,:,5]\n out_dict['Imagine'] = mat[:,:,6]\n out_dict['Potency'] = mat[:,:,7]\n out_dict['DomPot_Count'] = mat[:,:,8]\n out_dict['TokenCount'] = mat[:,:,9]\n out_dict['ValSq'] = mat[:,:,10]\n\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\n # Mean Values:\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DomPot_Count'])\n out_dict['MeanPotency'] = np.divide(out_dict['Potency'],out_dict['DomPot_Count'])\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\n # Percentages:\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\")\n elif method == 'discrete':\n if output == 'data_frame':\n mat['Pronoun_Percent'] = mat.Pronoun / mat.TokenCount\n mat['I_Percent'] = mat.I / mat.TokenCount\n mat['We_Percent'] = mat.We / mat.TokenCount\n mat['Self_Percent'] = mat.Self / mat.TokenCount\n mat['You_Percent'] = mat.You / mat.TokenCount\n mat['Other_Percent'] = mat.Other / mat.TokenCount\n mat['Negate_Percent'] = mat.Negate / mat.TokenCount\n mat['Assent_Percent'] = mat.Assent / mat.TokenCount\n mat['Article_Percent'] = mat.Article / mat.TokenCount\n mat['Preps_Percent'] = mat.Preps / mat.TokenCount\n mat['Number_Percent'] = mat.Number / mat.TokenCount\n mat['Affect_Percent'] = mat.Affect / mat.TokenCount\n mat['Posemo_Percent'] = mat.Posemo / mat.TokenCount\n mat['Posfeel_Percent'] = mat.Posfeel / mat.TokenCount\n mat['Optim_Percent'] = mat.Optim / mat.TokenCount\n mat['Negemo_Percent'] = mat.Negemo / mat.TokenCount\n mat['Anx_Percent'] = mat.Anx / mat.TokenCount\n mat['Anger_Percent'] = mat.Anger / mat.TokenCount\n mat['Sad_Percent'] = mat.Sad / mat.TokenCount\n mat['Cogmech_Percent'] = mat.Cogmech / mat.TokenCount\n mat['Cause_Percent'] = mat.Cause / mat.TokenCount\n mat['Insight_Percent'] = mat.Insight / mat.TokenCount\n mat['Discrep_Percent'] = mat.Discrep / mat.TokenCount\n mat['Inhib_Percent'] = mat.Inhib / mat.TokenCount\n mat['Tentat_Percent'] = mat.Tentat / mat.TokenCount\n mat['Certain_Percent'] = mat.Certain / mat.TokenCount\n mat['Senses_Percent'] = mat.Senses / mat.TokenCount\n mat['See_Percent'] = mat.See / mat.TokenCount\n mat['Hear_Percent'] = mat.Hear / mat.TokenCount\n mat['Feel_Percent'] = mat.Feel / mat.TokenCount\n mat['Social_Percent'] = mat.Social / mat.TokenCount\n mat['Comm_Percent'] = mat.Comm / mat.TokenCount\n mat['Othref_Percent'] = mat.Othref / mat.TokenCount\n mat['Friends_Percent'] = mat.Friends / mat.TokenCount\n mat['Family_Percent'] = mat.Family / mat.TokenCount\n mat['Humans_Percent'] = mat.Humans / mat.TokenCount\n mat['Time_Percent'] = mat.Time / mat.TokenCount\n mat['Past_Percent'] = mat.Past / mat.TokenCount\n mat['Present_Percent'] = mat.Present / mat.TokenCount\n mat['Future_Percent'] = mat.Future / mat.TokenCount\n mat['Space_Percent'] = mat.Space / mat.TokenCount\n mat['Up_Percent'] = mat.Up / mat.TokenCount\n mat['Down_Percent'] = mat.Down / mat.TokenCount\n mat['Incl_Percent'] = mat.Incl / mat.TokenCount\n mat['Excl_Percent'] = mat.Excl / mat.TokenCount\n mat['Motion_Percent'] = mat.Motion / mat.TokenCount\n mat['Occup_Percent'] = mat.Occup / mat.TokenCount\n mat['School_Percent'] = mat.School / mat.TokenCount\n mat['Job_Percent'] = mat.Job / mat.TokenCount\n mat['Achieve_Percent'] = mat.Achieve / mat.TokenCount\n mat['Leisure_Percent'] = mat.Leisure / mat.TokenCount\n mat['Home_Percent'] = mat.Home / mat.TokenCount\n mat['Sports_Percent'] = mat.Sports / mat.TokenCount\n mat['TV_Percent'] = mat.TV / mat.TokenCount\n mat['Music_Percent'] = mat.Music / mat.TokenCount\n mat['Money_Percent'] = mat.Money / mat.TokenCount\n mat['Metaph_Percent'] = mat.Metaph / mat.TokenCount\n mat['Relig_Percent'] = mat.Relig / mat.TokenCount\n mat['Death_Percent'] = mat.Death / mat.TokenCount\n mat['Physcal_Percent'] = mat.Physcal / mat.TokenCount\n mat['Body_Percent'] = mat.Body / mat.TokenCount\n mat['Sexual_Percent'] = mat.Sexual / mat.TokenCount\n mat['Eating_Percent'] = mat.Eating / mat.TokenCount\n mat['Sleep_Percent'] = mat.Sleep / mat.TokenCount\n mat['Groom_Percent'] = mat.Groom / mat.TokenCount\n mat['Swear_Percent'] = mat.Swear / mat.TokenCount\n mat['Nonfl_Percent'] = mat.Nonfl / mat.TokenCount\n mat['Fillers_Percent'] = mat.Fillers / mat.TokenCount\n mat['Swiss_Percent'] = mat.Swiss / mat.TokenCount\n mat['Ideo_Percent'] = mat.Ideo / mat.TokenCount\n mat['Personalpronomina_Percent'] = mat.Personalpronomina / mat.TokenCount\n mat['Indefinitpronomina_Percent'] = mat.Indefinitpronomina / mat.TokenCount\n mat['AuxiliaryVerbs_Percent'] = mat.AuxiliaryVerbs / mat.TokenCount\n mat['Konjunktionen_Percent'] = mat.Konjunktionen / mat.TokenCount\n mat['Adverbien_Percent'] = mat.Adverbien / mat.TokenCount\n mat['Detect_Percent'] = mat.LIWC_Counter / mat.TokenCount\n mat['Bedrohung_Percent'] = mat.Bedrohung / mat.TokenCount\n return(mat)\n\n elif output == 'array':\n out_dict = {}\n out_dict['Affect'] = mat[:,:,11]\n out_dict['Posemo'] = mat[:,:,12]\n out_dict['Posfeel'] = mat[:,:,13]\n out_dict['Optim'] = mat[:,:,14]\n out_dict['Negemo'] = mat[:,:,15]\n out_dict['Anx'] = mat[:,:,16]\n out_dict['Anger'] = mat[:,:,17]\n out_dict['Sad'] = mat[:,:,18]\n out_dict['Function'] = mat[:,:,0]\n out_dict['CogProc'] = mat[:,:,32]\n out_dict['DetectCount'] = mat[:,:,-2]\n out_dict['TokenCount'] = mat[:,:,-1]\n\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\n out_dict['DetectPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['DetectCount'])\n out_dict['OverallPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['TokenCount'])\n out_dict['DetectOptimPercent'] = np.divide(out_dict['Optim'], out_dict['DetectCount'])\n out_dict['OverallOptimPercent'] = np.divide(out_dict['Optim'], out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\n\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\") \n else:\n print(\"Error: Method not found!\") \n elif language == 'chinese':\n if method == 'dimensional':\n if output == 'data_frame':\n print(\"Error: This combination doesn't exist yet!\")\n elif output == 'array':\n print(\"Error: This combination doesn't exist yet!\")\n else:\n print(\"Error: Output Format not found!\")\n elif method == 'discrete':\n if output == 'data_frame':\n print(\"Error: This combination doesn't exist yet!\")\n elif output == 'array':\n out_dict = {}\n out_dict['Affect'] = mat[:,:,30]\n out_dict['Posemo'] = mat[:,:,31]\n out_dict['Negemo'] = mat[:,:,32]\n out_dict['Anx'] = mat[:,:,33]\n out_dict['Anger'] = mat[:,:,34]\n out_dict['Sad'] = mat[:,:,35]\n out_dict['Function'] = mat[:,:,0]\n out_dict['CogProc'] = mat[:,:,41]\n out_dict['DetectCount'] = mat[:,:,-2]\n out_dict['TokenCount'] = mat[:,:,-1]\n\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'], out_dict['TokenCount'])\n\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\") \n else:\n print(\"Error: Method not found!\") \n else:\n print(\"Error: Language not found!\")","def run_all_layers(self, img): # noqa\n s1_outputs = [s1(img) for s1 in self.s1_units]\n\n # Each C1 layer pools across two S1 layers\n c1_outputs = []\n for c1, i in zip(self.c1_units, range(0, len(self.s1_units), 2)):\n c1_outputs.append(c1(s1_outputs[i:i+2]))\n\n s2_outputs = [s2(c1_outputs) for s2 in self.s2_units]\n c2_outputs = [c2(s2) for c2, s2 in zip(self.c2_units, s2_outputs)]\n\n return s1_outputs, c1_outputs, s2_outputs, c2_outputs","def _derive_transformation_matrices(self):\n\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\n if self._primaries is not None and self._whitepoint is not None:\n npm = normalised_primary_matrix(self._primaries,\n self._whitepoint)\n\n self._derived_RGB_to_XYZ_matrix = npm\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)","def calc_CC_operation(el_output_from_GT_W, GT_size_W, fuel_type, T_sup_K):\n\n (eta0, m0_exhaust_GT_kgpers) = calc_GT_operation_fullload(GT_size_W, fuel_type)\n (eta, m_exhaust_GT_kgpers, T_exhaust_GT_K, m_fuel_kgpers) = calc_GT_operation_partload(el_output_from_GT_W,\n GT_size_W, eta0,\n m0_exhaust_GT_kgpers,\n fuel_type)\n\n (q_output_ST_W, el_output_ST_W) = calc_ST_operation(m_exhaust_GT_kgpers, T_exhaust_GT_K, T_sup_K, fuel_type)\n\n LHV = LHV_NG if fuel_type == 'NG' else LHV_BG # read LHV of NG or BG\n\n eta_el = (el_output_from_GT_W + el_output_ST_W) / (m_fuel_kgpers * LHV)\n eta_thermal = q_output_ST_W / (m_fuel_kgpers * LHV)\n eta_total = eta_el + eta_thermal\n el_output_W = el_output_ST_W + el_output_from_GT_W\n\n return {'el_output_W': el_output_W, 'q_output_ST_W': q_output_ST_W, 'eta_el': eta_el, 'eta_thermal': eta_thermal,\n 'eta_total': eta_total}","def coeff_display_M202(Nstar=1,seeing=[0.9,0.,0.],npix=npix,zenith=0,filter='r', theta=0., phi=0,corrector='corrector',x=0.,y=0.,z=0.,zernike_max_order=20,regular=False):\n hdu = genImgVallCCD(Nstar=Nstar,seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta,phi=phi, corrector=corrector,x=x,y=y,z=z,regular=regular)\n nn = len(hdu)\n data = []\n colnames = ['x','y','M20','M22','M31','M33']\n for hdui in hdu[1:]:\n Nobj = hdui.data.shape[0]\n M20=np.zeros(Nobj)\n M22=np.zeros(Nobj).astype(complex)\n M31=np.zeros(Nobj).astype(complex)\n M33=np.zeros(Nobj).astype(complex)\n for i in range(Nobj):\n img = hdui.data[i][4:].reshape(npix,npix)\n img = rebin(img,(40,40))\n M20,M22,M31,M33=complexMoments(data=img,sigma=4.)\n x=hdui.header['ccdXcen']\n y=hdui.header['ccdYcen']\n data.append([x,y,np.median(M20), np.median(M22), np.median(M31), np.median(M33)])\n data=np.array(data) \n betaAll=[]\n betaErrAll=[]\n R2adjAll=[]\n beta,betaErr,R2_adj,fitted = zernikeFit(data[:,0].real,data[:,1].real,data[:,2].real,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n for i in range(3,6):\n beta,betaErr,R2_adj,fitted = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].real,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n beta,betaErr,R2_adj,fitted = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].imag,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n betaAll = np.array(betaAll)\n betaErrAll = np.array(betaErrAll)\n R2adjAll = np.array(R2adjAll)\n ind = np.arange(len(betaAll[0]))\n momname = ('M20','M22.Real','M22.imag','M31.real','M31.imag','M33.real','M33.imag')\n fmtarr = ['bo-','ro-','go-','co-','mo-','yo-','ko-']\n pl.figure(figsize=(17,7))\n for i in range(3):\n pl.subplot(4,1,i+1)\n pl.errorbar(ind[1:],betaAll[i][1:],yerr = betaErrAll[i][1:],fmt=fmtarr[i])\n if i == 0:\n pl.title('x: '+str(hdu[0].header['x'])+' y: '+str(hdu[0].header['y'])+' z: '+str(hdu[0].header['z'])+' tilt: '+str(hdu[0].header['theta'])+' fwhm: '+str(hdu[0].header['s_fwhm'])+' e1: '+str(hdu[0].header['e1'])+' e2: '+str(hdu[0].header['e2']))\n pl.grid()\n pl.xlim(-1,len(betaAll[i])+1)\n pl.ylim(min(betaAll[i][1:])-0.5,max(betaAll[i][1:])+0.5)\n #pl.ylim(-0.1,0.1)\n pl.xticks(ind,('','','','','','','','','','','','','','','','','','','',''))\n pl.ylabel(momname[i])\n pl.xticks(ind,('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20'),rotation=90)\n pl.xlabel('Zernike Coefficients')\n return betaAll,betaErrAll","def residual_net_old(total_depth, data_layer_params, num_classes = 1000, acclayer = True):\n # figure out network structure\n net_defs = {\n 18:([2, 2, 2, 2], \"standard\"),\n 34:([3, 4, 6, 3], \"standard\"),\n 50:([3, 4, 6, 3], \"bottleneck\"),\n 101:([3, 4, 23, 3], \"bottleneck\"),\n 152:([3, 8, 36, 3], \"bottleneck\"),\n }\n assert total_depth in net_defs.keys(), \"net of depth:{} not defined\".format(total_depth)\n\n nunits_list, unit_type = net_defs[total_depth] # nunits_list a list of integers indicating the number of layers in each depth.\n nouts = [64, 128, 256, 512] # same for all nets\n\n # setup the first couple of layers\n n = caffe.NetSpec()\n n.data, n.label = L.Python(module = 'beijbom_caffe_data_layers', layer = 'ImageNetDataLayer',\n ntop = 2, param_str=str(data_layer_params))\n n.conv1, n.bn1, n.lrn1 = conv_bn(n.data, ks = 7, stride = 2, nout = 64, pad = 3)\n n.relu1 = L.ReLU(n.lrn1, in_place=True)\n n.pool1 = L.Pooling(n.relu1, stride = 2, kernel_size = 3)\n \n # make the convolutional body\n for nout, nunits in zip(nouts, nunits_list): # for each depth and nunits\n for unit in range(1, nunits + 1): # for each unit. Enumerate from 1.\n s = str(nout) + '_' + str(unit) + '_' # layer name prefix\n if unit_type == \"standard\":\n residual_standard_unit_old(n, nout, s, newdepth = unit is 1 and nout > 64)\n else:\n residual_bottleneck_unit_old(n, nout, s, newdepth = unit is 1)\n \n # add the end layers \n n.global_pool = L.Pooling(n.__dict__['tops'][n.__dict__['tops'].keys()[-1]], pooling_param = dict(pool = 1, global_pooling = True))\n n.score = L.InnerProduct(n.global_pool, num_output = num_classes,\n param=[dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0)])\n n.loss = L.SoftmaxWithLoss(n.score, n.label)\n if acclayer:\n n.accuracy = L.Accuracy(n.score, n.label)\n\n return n","def main():\n conf_matrix1 = one_vs_all()\n conf_matrix2 = all_vs_all()\n results = my_info() + '\\t\\t'\n results += np.array_str(np.diagonal(conf_matrix1)) + '\\t\\t'\n results += np.array_str(np.diagonal(conf_matrix2))\n print results + '\\t\\t'\n\n # sum = 0\n #\n # for i in range(len(conf_matrix1)):\n # sum += conf_matrix1[i][i]\n #\n # print \"One-vs-All corecct classifications: \", sum\n #\n # sum = 0\n #\n # for i in range(len(conf_matrix2)):\n # sum += conf_matrix2[i][i]\n #\n # print \"All-vs-All correct classificatinos: \", sum\n\n #print(\"onevsall\")\n #print_latex_table(conf_matrix1)\n #print(\"allvsall\")\n #print_latex_table(conf_matrix2)","def _final_aggregation(means_x: Tensor, means_y: Tensor, vars_x: Tensor, vars_y: Tensor, corrs_xy: Tensor, nbs: Tensor) ->Tuple[Tensor, Tensor, Tensor, Tensor, Tensor, Tensor]:\n mx1, my1, vx1, vy1, cxy1, n1 = means_x[0], means_y[0], vars_x[0], vars_y[0], corrs_xy[0], nbs[0]\n for i in range(1, len(means_x)):\n mx2, my2, vx2, vy2, cxy2, n2 = means_x[i], means_y[i], vars_x[i], vars_y[i], corrs_xy[i], nbs[i]\n nb = n1 + n2\n mean_x = (n1 * mx1 + n2 * mx2) / nb\n mean_y = (n1 * my1 + n2 * my2) / nb\n element_x1 = (n1 + 1) * mean_x - n1 * mx1\n vx1 += (element_x1 - mx1) * (element_x1 - mean_x) - (element_x1 - mean_x) ** 2\n element_x2 = (n2 + 1) * mean_x - n2 * mx2\n vx2 += (element_x2 - mx2) * (element_x2 - mean_x) - (element_x2 - mean_x) ** 2\n var_x = vx1 + vx2\n element_y1 = (n1 + 1) * mean_y - n1 * my1\n vy1 += (element_y1 - my1) * (element_y1 - mean_y) - (element_y1 - mean_y) ** 2\n element_y2 = (n2 + 1) * mean_y - n2 * my2\n vy2 += (element_y2 - my2) * (element_y2 - mean_y) - (element_y2 - mean_y) ** 2\n var_y = vy1 + vy2\n cxy1 += (element_x1 - mx1) * (element_y1 - mean_y) - (element_x1 - mean_x) * (element_y1 - mean_y)\n cxy2 += (element_x2 - mx2) * (element_y2 - mean_y) - (element_x2 - mean_x) * (element_y2 - mean_y)\n corr_xy = cxy1 + cxy2\n mx1, my1, vx1, vy1, cxy1, n1 = mean_x, mean_y, var_x, var_y, corr_xy, nb\n return mean_x, mean_y, var_x, var_y, corr_xy, nb","def __call__(self, affine, representations_list, aatype):\n act = [\n common_modules.Linear( # pylint: disable=g-complex-comprehension\n self.config.num_channel,\n name='input_projection')(jax.nn.relu(x))\n for x in representations_list\n ]\n # Sum the activation list (equivalent to concat then Linear).\n act = sum(act)\n\n final_init = 'zeros' if self.global_config.zero_init else 'linear'\n\n # Mapping with some residual blocks.\n for _ in range(self.config.num_residual_block):\n old_act = act\n act = common_modules.Linear(\n self.config.num_channel,\n initializer='relu',\n name='resblock1')(\n jax.nn.relu(act))\n act = common_modules.Linear(\n self.config.num_channel,\n initializer=final_init,\n name='resblock2')(\n jax.nn.relu(act))\n act += old_act\n\n # Map activations to torsion angles. Shape: (num_res, 14).\n num_res = act.shape[0]\n unnormalized_angles = common_modules.Linear(\n 14, name='unnormalized_angles')(\n jax.nn.relu(act))\n unnormalized_angles = jnp.reshape(\n unnormalized_angles, [num_res, 7, 2])\n angles = l2_normalize(unnormalized_angles, axis=-1)\n\n outputs = {\n 'angles_sin_cos': angles, # jnp.ndarray (N, 7, 2)\n 'unnormalized_angles_sin_cos':\n unnormalized_angles, # jnp.ndarray (N, 7, 2)\n }\n\n # Map torsion angles to frames.\n backb_to_global = r3.rigids_from_quataffine(affine)\n\n # Jumper et al. (2021) Suppl. Alg. 24 \"computeAllAtomCoordinates\"\n\n # r3.Rigids with shape (N, 8).\n all_frames_to_global = all_atom.torsion_angles_to_frames(\n aatype,\n backb_to_global,\n angles)\n\n # Use frames and literature positions to create the final atom coordinates.\n # r3.Vecs with shape (N, 14).\n pred_positions = all_atom.frames_and_literature_positions_to_atom14_pos(\n aatype, all_frames_to_global)\n\n outputs.update({\n 'atom_pos': pred_positions, # r3.Vecs (N, 14)\n 'frames': all_frames_to_global, # r3.Rigids (N, 8)\n })\n return outputs","def forward_propagate(self):\n for i in range(0, len(self.output_layer)):\n output = 0\n\n # Loop through each Neuron in the hidden layer\n for neuron in self.hidden_layer:\n output += neuron.weights[i] * neuron.output\n\n # Update summation for output classifier\n self.output_layer[i] = output","def _inexact_alm_l1(imgflt_stack,options):\n # Get basic image information and reshape input\n img_width = imgflt_stack.shape[0]\n img_height = imgflt_stack.shape[1]\n img_size = img_width* img_height\n img_3d = imgflt_stack.shape[2]\n imgflt_stack = np.reshape(imgflt_stack,(img_size, img_3d))\n options['weight'] = np.reshape(options['weight'],imgflt_stack.shape)\n\n # Matrix normalization factor\n temp = np.linalg.svd(imgflt_stack,full_matrices=False,compute_uv=False)\n norm_two = np.float64(temp[0])\n del temp\n\n # A is a low rank matrix that is being solved for\n A = np.zeros(imgflt_stack.shape,dtype=np.float64)\n A_coeff = np.ones((1, img_3d),dtype=np.float64) # per image scaling coefficient, accounts for things like photobleaching\n A_offset = np.zeros((img_size,1),dtype=np.float64) # offset per pixel across all images\n\n # E1 is the additive error. Since the goal is determining the background signal, this is the real signal at each pixel\n E1 = np.zeros(imgflt_stack.shape,dtype=np.float64)\n\n # Normalization factors\n ent1 = np.float64(1) # flatfield normalization\n ent2 = np.float64(10) # darkfield normalization\n\n # Weights\n weight_upd = _dct2(np.mean(np.reshape(A,(img_width, img_height, img_3d)),2))\n\n # Initialize gradient and weight normalization factors\n Y1 = np.float64(0)\n mu = np.float64(12.5)/norm_two\n mu_bar = mu * 10**7\n rho = np.float64(1.5)\n\n # Frobenius norm\n d_norm = np.linalg.norm(imgflt_stack,'fro')\n\n # Darkfield upper limit and offset\n B1_uplimit = np.min(imgflt_stack)\n B1_offset = np.float64(0)\n\n # Perform optimization\n iternum = 0\n converged = False\n while not converged:\n iternum += 1\n\n # Calculate the flatfield using existing weights, coefficients, and offsets\n W_idct_hat = _idct2(weight_upd)\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\n temp_W = np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\n\n # Update the weights\n temp_W = np.reshape(temp_W,(img_width, img_height, img_3d))\n temp_W = np.mean(temp_W,2)\n weight_upd = weight_upd + _dct2(temp_W)\n weight_upd = np.max(np.reshape(weight_upd - options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0) + np.min(np.reshape(weight_upd + options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0)\n W_idct_hat = _idct2(weight_upd)\n\n # Calculate the flatfield using updated weights\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\n\n # Determine the error\n E1 = E1 + np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\n E1 = np.max(np.reshape(E1 - options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0) + np.min(np.reshape(E1 + options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0)\n\n # Calculate the flatfield coefficients by subtracting the errors from the original data\n R1 = imgflt_stack-E1\n A_coeff = np.reshape(np.mean(R1,0)/np.mean(R1),(1, img_3d))\n A_coeff[A_coeff<0] = 0 # pixel values should never be negative\n\n # Calculate the darkfield component if specified by the user\n if options['darkfield']:\n # Get images with predominantly background pixels\n validA1coeff_idx = np.argwhere(A_coeff<1)[:,1]\n R1_upper = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1)).astype(np.float64)>(np.float64(np.mean(W_idct_hat))-np.float64(10**-5)))[:,0],:]\n R1_upper = np.mean(R1_upper[:,validA1coeff_idx],0)\n R1_lower = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1)) options['max_iterations']:\n converged = True\n\n # Calculate final darkfield image\n A_offset = A_offset + B1_offset * np.reshape(W_idct_hat,(-1,1))\n\n return A,E1,A_offset","def reconstruct(X_input, X_mean, X_std, Y, P, e_scaled, x_col = 0, y_col = 1, dimensions = [0, 1, 2, 3]):\n\t# Reconstruction degrees information retention (~25%, ~50%, ~75%, and ~100%).\n\tfor d in dimensions:\n\t\t# Reconstruct \n\t\tY_proj = Y.iloc[:,0:(d + 1)]\n\t\tX_rec = (Y_proj @ P.iloc[:,0:(d + 1)].T) * X_std + X_mean\n\t\tX_rec.columns = X_input.columns\n\n\t\t# Cumulate percentage information retained\n\t\tdata_retained = e_scaled[range(d + 1)].sum() * 100\n\n\t\tml.plt.figure()\n\t\tml.plt.title(f'Raw vs. Reconstructed D = {d + 1}')\n\t\tml.sns.scatterplot(data = X_input, x = X_input.iloc[:, x_col], y = X_input.iloc[:, y_col], alpha = 0.5, color = 'k', label = 'Raw Data (100%)')\n\t\tml.sns.scatterplot(data = X_rec, x = X_rec.iloc[:, x_col], y = X_rec.iloc[:, y_col], alpha = 0.5, color = 'r', label = f'Reconstructed Data ({data_retained: .2f}%)')","def connector_mediation(task):\n\tatlas = 'power'\n\tproject='hcp'\n\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\n\tsubjects = np.load('%s/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %(homedir,'hcp',task,atlas))\n\tstatic_results = graph_metrics(subjects,task,atlas,run_version='fz')\n\tmatrices = static_results['matrices']\n\tsubject_pcs = static_results['subject_pcs']\n\tsubject_mods = static_results['subject_mods']\n\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\n\tfor i in range(subject_pcs.shape[1]):\n\t\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\n\tmean_conn = np.nanmean(matrices,axis=0)\n\te_tresh = np.percentile(mean_conn,85)\n\tsubject_pcs[np.isnan(subject_pcs)] = 0.0\n\tm = np.zeros((264,264,264))\n\tpool = Pool(40)\n\tfor n in range(264):\n\t\tprint n\n\t\tsys.stdout.flush()\n\t\tvariables = []\n\t\tfor i,j in combinations(range(264),2):\n\t\t\tvariables.append(pd.DataFrame(data={'pc':subject_pcs[:,n],'weight':matrices[:,i,j],'q':subject_mods},index=range(len(subject_pcs))))\n\t\tresults = pool.map(multi_med,variables)\n\t\tfor r,i in zip(results,combinations(range(264),2)):\n\t\t\tm[n,i[0],i[1]] = r\n\t\t\tm[n,i[1],i[0]] = r\n\t\tnp.save('/home/despoB/mb3152/dynamic_mod/results/full_med_matrix_new_%s.npy'%(task),m)","def TNFR1_to_SecondaryComplex():\n \n Parameter('TNFa_0' , 5000) # 3000 corresponds to 50ng/ml TNFa\n Parameter('TNFR1_0' , 200) # 200 receptors per cell\n Parameter('TRADD_0' , 1000) # molecules per cell (arbitrarily assigned)1000\n Parameter('CompI_0' , 0) # complexes per cell\n Parameter('RIP1_0' , 20000) # molecules per cell 20000\n Parameter('NFkB_0' , 0) # molecules per cell\n \n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\n Initial(RIP1(bDD=None, bRHIM = None, state = 'ub'), RIP1_0) # RIP1\n Initial(NFkB(bf=None), NFkB_0)\n\n # =========================================\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\n # -----------------------------------------\n # TNFa+ TNFR1 <-> TNFa:TNFR1\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub \n \n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\n # [active]CompI:RIP1 >> [active]CompI + RIP1\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\n\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it. \n\n # ------------------------------------------\n \n # -------------Complex I assembly----------------\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [KF, KR])\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [KF, KR])\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), KC)\n \n # --------------Complex I - RIP1 Modification-----------------\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[KF, KR])\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR]) \n \n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'),KC)\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [Parameter('k2', 0), KR])\n #Rule('RIP1_rel', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod') + RIP1(bDD=None, bRHIM = None, state = 'unmod'), KC3)\n #bind(CompI(bDD=None, state = 'mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR])\n #Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod'),KC3)\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), KC)\n Rule('NFkB_expression', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), KE)\n # --------------RIP1 Ubiquitination---------------------------\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), KC2)\n # Rule('RIP1_deUb', RIP1(bDD=None, bRHIM = None, state='ub')>> RIP1(bDD=None, bRHIM = None, state='unmod'), KR)","def forward_pass(X,architecture):\n \n architecture['layer1'][0] = X\n kernel_shape1 = architecture['layer1'][7]\n stride1 = architecture['layer1'][8]\n if kernel_shape1 is not None and not isinstance(kernel_shape1,int):\n X_input_1_im2col,imX = im2col(X,kernel_shape1,stride1,im_needed = False, shape_specified = True)\n architecture['layer1'][4] = X_input_1_im2col\n else:\n architecture['layer1'][4] = None\n\n for layer in range(len(architecture)): # Feedforward from the first till the second last layer\n X_input,X_output,weightsi,biasi,X_input_1_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imx = architecture['layer{}'.format(layer+1)]\n\n if operationi == 'conv_bn_relu':\n conv_output = relu(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'conv_relu':\n conv_output = relu(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'conv_bn_sigmoid':\n conv_output = sigmoid(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'conv_sigmoid':\n conv_output = sigmoid(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\n conv_output = torch.reshape(conv_output,output_shapei)\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n if operationi__1 == 'maxpool':\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\n else:\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n # resetting input im2col of next layer as the im2col of the output of this layer\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'maxpool':\n maxpool_output = maxpool(X_input,kernel_shapei,stridei)\n\n maxpool_output = torch.reshape(maxpool_output,output_shapei)\n\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = maxpool_output\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\n architecture['layer{}'.format(layer+2)][4],imX = im2col(maxpool_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\n else:\n architecture['layer{}'.format(layer+2)][4] = None\n elif operationi == 'flatten_dense_relu':\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'relu',initialise_weights = False)\n architecture['layer{}'.format(layer+1)][1] = output\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = output\n elif operationi == 'flatten_dense_none':\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'none',initialise_weights = False)\n architecture['layer{}'.format(layer+1)][1] = output\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = output\n elif operationi == 'flatten_dense_sigmoid':\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'sigmoid',initialise_weights = False)\n architecture['layer{}'.format(layer+1)][1] = output\n if layer != len(architecture) - 1:\n architecture['layer{}'.format(layer+2)][0] = output\n elif operationi == 'softmax':\n Xin = architecture['layer{}'.format(layer+1)][0]\n output = softmax(Xin).squeeze()\n architecture['layer{}'.format(layer+1)][1] = output\n if layer == len(architecture) - 1:\n y_pred = architecture['layer{}'.format(len(architecture))][1]\n \n return y_pred","def _apply_individual_nbody1_accumulate_python(\n coeff: 'Nparray', ocoeff: 'Nparray', icoeff: 'Nparray',\n amap: 'Nparray', btarget: 'Nparray', bsource: 'Nparray',\n bparity: 'Nparray') -> None:\n for sourcea, targeta, paritya in amap:\n ocoeff[targeta, btarget] += coeff * paritya * numpy.multiply(\n icoeff[sourcea, bsource], bparity)","def explain(self):\n # build the 2 versions of the model\n model = self.build_model()\n last_conv_model = self.build_cut_model()\n\n for i, label_name in enumerate(self.label_names):\n # This is the algorithm for the last convolution layer's tensor image\n # Get the index of the image that was classified correctly with the most confidence for the class\n predicted_col_proba = np.array(self.predicted_labels)[0][:, i]\n predicted_col_argsort = predicted_col_proba.argsort()[::-1]\n predicted_col = (predicted_col_proba > 0.2).astype(int)\n true_col = self.true_labels[:, 0]\n\n representative_image_index = None\n for most_probable_arg_index in predicted_col_argsort:\n if predicted_col[most_probable_arg_index] == true_col[most_probable_arg_index]:\n representative_image_index = most_probable_arg_index\n break\n\n # Resize the image to fit the neural network and keep the original resized image\n original_img = io.imread('{}/{}/{}'.format(path_to_img_directory, self.ex_format, np.array(self.image_names)[representative_image_index]))\n original_img = cv2.normalize(original_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\n original_img = cv2.resize(original_img, dsize=(self.ex_input_size, self.ex_input_size), interpolation=cv2.INTER_CUBIC)\n img = np.expand_dims(original_img, axis=0)\n original_img = original_img[:, :, :3]\n\n # Get the output of the neural network for this image as a tensor\n model.predict(np.array(img))\n class_output = model.output[:, i]\n last_conv_layer = model.get_layer(self.ex_last_conv_layer_name1).output\n # if self.model_name == 'vit':\n # last_conv_layer = tf.nn.relu(tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024)))\n\n # Get the output for the cut model\n cut_img = last_conv_model.predict(np.array(img))[0]\n if self.model_name == 'vit':\n cut_img = np.reshape(cut_img[:256, :], (16, 16, 1024))\n cut_img = np.mean(cut_img, axis=-1)\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\n if self.model_name == 'vit':\n cut_img[0, 0] = np.mean(cut_img)\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\n cut_img = cv2.resize(cut_img, (self.ex_input_size, self.ex_input_size))\n\n # This is the algorithm of the Grad-CAM model\n # Refine the output of the last convolutional layer according to the class output\n grads = K.gradients(class_output, last_conv_layer)[0]\n if self.model_name == 'vit':\n last_conv_layer = tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024))\n last_conv_layer = last_conv_layer / tf.norm(last_conv_layer)\n\n grads = tf.reshape(grads[:, :256, :], (-1, 16, 16, 1024))\n grads = grads / tf.norm(grads)\n\n pooled_grads = K.mean(grads, axis=(0, 1, 2))\n iterate = K.function([model.input], [pooled_grads, last_conv_layer[0]])\n pooled_grads_value, conv_layer_output_value = iterate([img])\n for j in range(self.ex_last_conv_layer_filter_number):\n conv_layer_output_value[:, :, j] *= pooled_grads_value[j]\n\n # Create a 16x16 heatmap and scale it to the same size as the original image\n heatmap = np.mean(conv_layer_output_value, axis=-1)\n heatmap = np.maximum(heatmap, 0)\n heatmap /= np.max(heatmap)\n heatmap = cv2.resize(heatmap, (self.ex_input_size, self.ex_input_size))\n heatmap = np.uint8(255 * heatmap)\n heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)\n heatmap = cv2.normalize(heatmap, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\n superimposed_img = cv2.addWeighted(original_img, 0.7, heatmap, 0.4, 0)\n\n # save the original image\n plt.matshow(original_img)\n plt.axis('off')\n plt.title(label_name, fontdict={'fontsize': 18})\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'original', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\n\n # save the cut image\n plt.matshow(cut_img, cmap=plt.get_cmap('Spectral'))\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\n plt.axis('off')\n plt.title(label_name, fontdict={'fontsize': 18})\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'cut', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\n\n # save the superimposed gradcam image\n plt.matshow(superimposed_img, cmap=plt.get_cmap('Spectral'))\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\n plt.axis('off')\n plt.title(label_name, fontdict={'fontsize': 18})\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'gradcam', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)","def process(self, mat):","def UpdateLayers(self):\n pass","def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\n dtype=np.float32):\n self.params = {}\n self.reg = reg\n self.dtype = dtype\n \n ############################################################################\n # TODO: Initialize weights and biases for the three-layer convolutional #\n # network. Weights should be initialized from a Gaussian with standard #\n # deviation equal to weight_scale; biases should be initialized to zero. #\n # All weights and biases should be stored in the dictionary self.params. #\n # Store weights and biases for the convolutional layer using the keys 'W1' #\n # and 'b1'; use keys 'W2' and 'b2' for the weights and biases of the #\n # hidden affine layer, and keys 'W3' and 'b3' for the weights and biases #\n # of the output affine layer. #\n ############################################################################ \n C, H, W = input_dim;\n\n # Dimensions of data output by convolutional layer\n S = 1; pad = (filter_size - 1) / 2; # Stride and image padding\n hconv = (H - filter_size + 2*pad)/S + 1;\n wconv = (W - filter_size + 2*pad)/S + 1;\n\n # Get dimensions of 2x2 max-pool output\n hmp = hconv / 2;\n wmp = wconv / 2;\n\n # Get dimensions of vector fed into affine layer\n # Convert maxpool output by using np.reshape(v1,(N,-1))\n # Recover by using np.reshape(dv1,v1.shape)\n laff = hmp*wmp*num_filters;\n\n # Determine starting weight and bias matrices\n self.params['W1'] = weight_scale * np.random.randn(num_filters, C, filter_size, filter_size);\n self.params['b1'] = np.zeros(num_filters);\n self.params['W2'] = weight_scale * np.random.randn(laff, hidden_dim);\n self.params['b2'] = np.zeros(hidden_dim);\n self.params['W3'] = weight_scale * np.random.rand(hidden_dim,num_classes);\n self.params['b3'] = np.zeros(num_classes);\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n for k, v in self.params.iteritems():\n self.params[k] = v.astype(dtype)","def reduce(self,predictor):\n span,stack_top=self\n s0,s1,s2=stack_top\n if s0==None or s1==None:return []\n p_span,pstack=predictor\n\n print('reduce>>>>>>>>',self)\n\n rtn= [\n (ord('L'),pickle.dumps(( # ind\n (p_span[0],span[1]), #span\n ((s1[0],s1[1],s0[0]),pstack[1],pstack[2]))), ##\n ),\n (ord('R'),pickle.dumps(( #\n (p_span[0],span[1]),\n ((s0[0],s1[0],s0[2]),pstack[1],pstack[2]))),\n ),\n ]\n return rtn","def compute_model(self, A_on_basis_vecs, B_on_standard_basis_array,\n C_on_basis_vecs):\n self.reduce_A(A_on_basis_vecs)\n self.reduce_B(B_on_standard_basis_array)\n self.reduce_C(C_on_basis_vecs)\n return self.A_reduced, self.B_reduced, self.C_reduced"],"string":"[\n \"def MotcorCatenate(self, info, base, anat_tgt):\\n# First compute the transformation matrices due to epi-to-epi motion.\\n fmt = '3dvolreg -prefix NULL -1Dmatrix_save %s -twopass ' + \\\\\\n '-verbose -base %s+orig[%s] -dfile %s %s+orig'\\n cmd = fmt % (info['matfile_m'], info['basefile'], base, \\\\\\n info['mot_file'], info['imgfile_t'])\\n self.CheckExec(cmd, [info['matfile_m']])\\n\\n# Catenate with transformation from epi base image to the anatomical.\\n cmd = 'cat_matvec -ONELINE %s -P %s -P > %s' % \\\\\\n (self.info[anat_tgt]['matfile'], info['matfile_m'], \\\\\\n info['matfile_mcat'])\\n self.CheckExec(cmd, [info['matfile_mcat']])\\n\\n# Interpolate the data to the new grid.\\n fmt = '3dAllineate -prefix %s -interp cubic -1Dmatrix_apply %s ' + \\\\\\n '-warp shift_rotate -base %s+orig[%s] %s+orig'\\n cmd = fmt % (info['imgfile_m'], info['matfile_mcat'], info['basefile'], \\\\\\n base, info['imgfile_t'])\\n self.CheckExec(cmd, ['%s+orig.BRIK'%info['imgfile_m'], \\\\\\n '%s+orig.HEAD'%info['imgfile_m']])\",\n \"def main():\\n feature_extraction_model = \\\"HOG\\\"\\n # feature_extraction_models = [\\\"CM\\\", \\\"HOG\\\"]\\n feature_extraction_model_1 = \\\"CM\\\"\\n dimension_reduction_model = \\\"PCA\\\"\\n k_value = 10\\n dim_k_value = 40\\n # K_value = 20\\n # lab_folder = \\\"Dataset3/Labelled/Set1\\\"\\n # unlab_folder = \\\"Dataset3/Unlabelled/Set 2\\\"\\n lab_folder = get_input_folder(\\\"Labelled Folder\\\")\\n unlab_folder = get_input_folder(\\\"Classify\\\")\\n start = time.time()\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab = dim_red.get_object_feature_matrix()\\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\\n images_list_lab = np.array(obj_feat_lab['imageId'])\\n # filtering the labelled set\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab = dim_red.get_object_feature_matrix()\\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\\n # filtering the labelled set\\n\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\\n\\n # ================================================================================================================\\n\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n features_list = np.concatenate((features_list_lab, features_list_unlab))\\n images_list = np.concatenate((images_list_lab, images_list_unlab))\\n images_list = list(images_list)\\n # Finding Similarity Matrix\\n cos_sim = cosine_similarity(features_list)\\n sim_graph = np.empty((0, len(cos_sim)))\\n for row in cos_sim:\\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\\n\\n row_sums = sim_graph.sum(axis=1)\\n sim_graph = sim_graph / row_sums[:, np.newaxis]\\n idx = 0\\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\\n results_palmar = ppr(sim_graph, images_list, palmar_list)\\n final_results = {}\\n\\n for img in images_list_unlab:\\n if results_dorsal[img] < results_palmar[img]:\\n final_results[img] = \\\"dorsal\\\"\\n else:\\n final_results[img] = \\\"palmar\\\"\\n\\n actual_labels = fetch_actual_labels(images_list_unlab)\\n print(\\\"Classification\\\")\\n no_correct = 0\\n correctly_classified = []\\n incorrectly_classified = []\\n print(\\\"| ImageId | Prediction | Actual |\\\")\\n for r in final_results:\\n print(\\\"| {} | {} | {} |\\\".format(r, final_results[r], actual_labels[r]))\\n if final_results[r] == actual_labels[r]:\\n correctly_classified.append(r)\\n no_correct += 1\\n else:\\n incorrectly_classified.append(r)\\n\\n print(\\\"Correctly classified: {}\\\\n\\\".format(correctly_classified))\\n print(\\\"InCorrectly classified: {}\\\\n\\\".format(incorrectly_classified))\\n\\n print(\\\"Classification Accuracy: {}%\\\".format(no_correct / len(images_list_unlab) * 100))\\n print(\\\"Execution time: {} seconds\\\".format(time.time() - start))\",\n \"def implement_processing(self, output_intermediate, processing_matrix, forward = True):\\n \\n # Attention implementation\\n output_intermediate = torch.matmul(output_intermediate, processing_matrix)\\n output_intermediate = torch.transpose(output_intermediate,2,1)\\n \\n # Linear layer output reduction \\n # from [batch, hidden_size, input_size - 1] to [batch, hidden_size,1]\\n # different linear layers required to ensure good performance\\n if forward:\\n output_reduced = self.linear_fw(output_intermediate).squeeze(2)\\n else:\\n output_reduced = self.linear_bw(output_intermediate).squeeze(2)\\n \\n output_reduced = self._activation_fn(output_reduced)\\n \\n return output_reduced\",\n \"def estimateInfo(Analysis, ImageData, diffract, print_opt=False): \\n total_images = ImageData['totalImages'] \\n\\n for key in Analysis:\\n Analysis[key]['cones'] = [1,2,3,4,5,6]\\n Analysis[key]['info'] = np.zeros(len(\\n Analysis[key]['cones']))\\n\\n for amp in ImageData['rawAmp']:\\n\\n for key in Analysis:\\n ind = len(diffract['cpd'])\\n fooInfo = info.SingleConeEntropyFunc((amp[ind] ** 2 *\\n Analysis[key]['retina']), \\n Analysis[key]['cones']) \\n Analysis[key]['info'] += fooInfo / total_images\\n\\n if print_opt == True:\\n print ' '\\n print 'Information'\\n print '------------'\\n for key in Analysis:\\n print key, ': ', Analysis[key]['info']\\n\\n return Analysis\",\n \"def _process_matrices(self, **kwargs):\\n\\n if self.datasource == 'graph':\\n # Must store the adj_matrix\\n self.data.adjacencymat = self.data.adj_matrix()\\n return self._sum_on_axis(self.data.adjacencymat, **kwargs)\\n elif self.datasource == 'custom':\\n return self._sum_on_axis(self.data, **kwargs)\\n elif self.datasource == 'MRD':\\n return {k: self._sum_on_axis(self.data.data[k].todense(), undirected=False) for k in self.data.data.keys() if k != 'pk'}\",\n \"def sublayer_reconstruct(self, layer, sublayer, timesurface, method,\\n noise_ratio, sparsity_coeff, sensitivity):\\n if method == \\\"CG\\\":\\n error = self.sublayer_response_CG(layer, sublayer,\\n timesurface,\\n sparsity_coeff,\\n noise_ratio)\\n if method == \\\"Exp distance\\\": \\n error = self.sublayer_response_exp_distance(layer, sublayer,\\n timesurface,\\n sparsity_coeff, \\n noise_ratio, \\n sensitivity)\\n if method==\\\"Dot product\\\":\\n error = self.sublayer_response_dot_product(layer, sublayer,\\n timesurface,\\n sparsity_coeff, \\n noise_ratio, \\n sensitivity)\\n print(\\\"Layer activity : \\\")\\n print(self.activations[layer][sublayer]) \\n S_tilde = sum([a*b for a,b in zip(self.basis[layer][sublayer],\\n self.activations[layer][sublayer])]) \\n plt.figure(\\\"Reconstructed Figure\\\")\\n sns.heatmap(S_tilde)\\n print(\\\"Reconstruction error : \\\")\\n print(error)\\n return error\",\n \"def cal_topology_feature(self):\\n self.NPL()\\n self.topo_efficiency_cal()\\n self.efficiency_cal()\\n self.cluster_cal()\\n self.topo_diameter()\\n self.spatial_diameter()\",\n \"def data_model_residual(surface, dem, unw, incidence):\\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\\n\\n # Using image_grid\\n fig = plt.figure()\\n grid = ImageGrid(fig, 111, # similar to subplot(111)\\n nrows_ncols = (1, 3),\\n direction=\\\"row\\\",\\n axes_pad = 0.05,\\n add_all=True,\\n label_mode = \\\"1\\\",\\n share_all = True,\\n cbar_location=\\\"top\\\",\\n cbar_mode=\\\"each\\\", #\\\"single\\\"\\n cbar_size=\\\"5%\\\",\\n cbar_pad=0.05,\\n )\\n #grid[0].set_xlabel(\\\"X\\\")\\n #grid[0].set_ylabel(\\\"Y\\\")\\n #grid2[0].set_xticks([-2, 0])\\n #grid2[0].set_yticks([-2, 0, 2])\\n\\n #NOTE: could find global min/max from three arrays here\\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\\n #for ax,data in zip(grid,[los,fem_los,residual]):\\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n grid[0].axhline(100,color='m') #show profile\\n cax = grid.cbar_axes[0]\\n cax.colorbar(im)\\n grid[1].axhline(100,color='k') #show profile\\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n\\n cax = grid.cbar_axes[1]\\n cax.colorbar(im1)\\n\\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\\n cax = grid.cbar_axes[2]\\n cax.colorbar(im2)\\n\\n # Add letter labels\\n for ax, label in zip(grid,['A', 'B', 'C']):\\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\\n fontsize=16, fontweight='bold', va='top')\\n\\n # Annotate\\n # NOTE: way too high!\\n #plt.suptitle('FEM Results')\\n\\n # Add profile\\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\\n fig = plt.figure()\\n #x = arange(los.shape[0])\\n plt.axhline(color='k',ls='--')\\n plt.plot(los[100],'m.',label='data')\\n plt.plot(fem_los[100],'k-',lw=2,label='model')\\n plt.xlabel('Distance [km]')\\n plt.ylabel('Distance [km]')\\n plt.legend(loc='upper left')\\n\\n plt.show()\",\n \"def data_augmentation_and_vectorization(self,imlist, lb,im_labels, average_image = None):\\n\\t\\tX,Y,X_original = [] ,[], []\\n\\n\\t\\ti = 0\\n\\t\\tfor im in imlist:\\n\\t\\t\\tim=Image.fromarray(im,mode=self.mode)\\n\\t\\t\\t#try:\\n\\t\\t\\t#im_ini = im\\n\\t\\t\\tim_original = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t#im = self.substract_average_image(im, average_image)\\n\\t\\t\\t#print 'i:{} is a: {}' .format(i,im_labels[i])\\n\\t\\t\\t#im.show()\\n\\t\\t\\tX_original.append(im_original)\\n\\n\\t\\t\\t#Rotations \\n\\t\\t\\t#im_r = im.rotate(15)\\n\\t\\t\\t# im_r_2 = im.rotate(-15)\\n\\t\\t\\t# im_r_3 = im.rotate(180)\\n\\t\\t\\t#im_r.show()\\n\\t\\t\\t#im_r_2.show()\\n\\n\\t\\t\\t#Filters\\n\\t\\t\\t#im_f = im_ini.filter(ImageFilter.DETAIL)\\n\\t\\t\\t#im_f = im.filter(ImageFilter.FIND_EDGES)\\n\\t\\t\\t\\n\\t\\t\\tif self.mode == 'RGB':\\n\\t\\t\\t\\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\t#Uncomment this if you want to use cross-correlate for 2D arrays http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.signal.correlate2d.html\\n\\t\\t\\t\\t# im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\t# im = sp.inner(im, [299, 587, 114]) / 1000.0\\n\\t\\t\\t\\t# im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\\n\\t\\t\\t\\t# im = (im - im.mean()) / im.std()\\n\\n\\t\\t\\tif self.mode == 'L':\\n\\t\\t\\t\\t# im = np.asarray(im, dtype='float64')\\n\\t\\t\\t\\t# im = filters.sobel(im)\\n\\t\\t\\t\\t#im = filters.roberts(im)\\n\\t\\t\\t\\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\n\\t\\t\\t#im = np.asarray(im, dtype=np.uint8)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t#im = self.flaten_aux(im)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#im = data.coins() # or any NumPy arr\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#image = data.coins() # or any NumPy array!\\n\\t\\t\\t#print im\\n\\t\\t\\t#im = filter.sobel(im)\\n\\t\\t\\t#im = filter.roberts(im)\\n\\n\\t\\t\\t# im_original = sp.inner(im, [299, 587, 114]) / 1000.0\\n\\t\\t\\t# im_original = np.asarray(im_original, dtype=theano.config.floatX)\\n\\t\\t\\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\\n\\t\\t\\t# im = (im_original - im_original.mean()) / im_original.std()\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#print edges\\n\\t\\t\\t# edges = np.asarray(edges, dtype=np.uint8)\\n\\t\\t\\t#Image.fromarray(edges,mode=self.mode).show()\\n\\n\\t\\t\\t#print edges\\n\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\n\\t\\t\\t#print edges.shape\\n\\t\\t\\t# io.imshow(im)\\n\\t\\t\\t# io.show()\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\n\\t\\t\\t# plt.suptitle(im_labels[i], size=16)\\n\\t\\t\\t# plt.imshow(im, cmap=plt.cm.gray, interpolation='nearest')\\n\\t\\t\\t# plt.show()\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#self.reconstructImage(im).show()\\n\\n\\t\\t\\t#im_r = np.asarray(im_r, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t# im_r_2 = np.asarray(im_r_2, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t# im_r_3 = np.asarray(im_r_3, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t#im_f = np.asarray(im_f, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\n\\t\\t\\t#im = im.transpose(2, 0, 1)\\n\\t\\t\\t#X.append(np.array(im, dtype=theano.config.floatX))\\n\\t\\t\\t#X.append(np.array(im_raw, dtype=theano.config.floatX))\\n\\t\\t\\t#X.append(im)\\n\\t\\t\\tX.append(im)\\n\\t\\t\\t# if i % 100 == 0:\\n\\t\\t\\t# \\tX.append(im)\\n\\t\\t\\t#X.append(im_r)\\n\\t\\t\\t# X.append(im_r_2)\\n\\t\\t\\t# X.append(im_r_3)\\n\\t\\t\\t#X.append(im_f)\\n\\t\\t\\t#X_original.append(im)\\n\\n\\t\\t\\t# X.append(np.array(im_r, dtype=theano.config.floatX))\\n\\t\\t\\t# X.append(np.array(im_r_2, dtype=theano.config.floatX))\\n\\n\\t\\t\\t#Uncomment this if you want to work with monochrome\\n\\t\\t\\t# im = im.convert('L')\\n\\t\\t\\t# pixels_monochrome = np.array(list(im.getdata()), dtype=np.float)\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t# # scale between 0-1 to speed up computations\\n\\t\\t\\t# min_max_scaler = preprocessing.MinMaxScaler(feature_range=(0,1), copy=True)\\n\\t\\t\\t# pixels_monochrome = min_max_scaler.fit_transform(pixels_monochrome)\\n\\n\\t\\t\\t# X.append(pixels_monochrome)\\n\\n\\t\\t\\t#Y.append(lb.transform([im_labels[i]])[0][0])\\n\\t\\t\\t#print lb.transform([im_labels[i]])\\n\\t\\t\\t\\n\\t\\t\\tlabel = lb.transform([im_labels[i]])[0][0]\\n\\t\\t\\t#print lb.transform([im_labels[i]])\\n\\t\\t\\t# label_vector = lb.transform([im_labels[i]])[0]\\n\\t\\t\\t# label = np.where( label_vector == 1 )[0][0]\\n\\t\\t\\t# print \\\"Label: {}\\\".format(label)\\n\\t\\t\\t#print label\\n\\t\\t\\t#Y.append(label)\\n\\t\\t\\tY.append(label)\\n\\t\\t\\t#Y.append(im_labels[i])\\t\\n\\n\\t\\t\\t\\n\\t\\t\\t#Y.append(label)\\t\\n\\t\\t\\t# Y.append(label)\\t\\n\\t\\t\\t# except Exception, e:\\n\\t\\t\\t# \\tprint e\\n\\t\\t\\t# \\t#raise e\\n\\n\\t\\t\\t# if i == 30:\\n\\t\\t\\t# \\tbreak\\n\\n\\t\\t\\ti += 1\\n\\t\\t\\tif self.verbose:\\n\\t\\t\\t\\tsys.stdout.write(\\\"\\\\r Process: {0}/{1}\\\".format(i, len(imlist)))\\n\\t\\t\\t\\tsys.stdout.flush()\\n\\t\\t\\n\\t\\t# output = open(self.data_path + 'X_original.pkl', 'wb')\\n\\t\\t# cPickle.dump(X_original, output,protocol=-1)\\n\\t\\t# output.close()\\n\\n\\t\\treturn X,Y\",\n \"def combined_costs(matrix_MSLL_IO):\\r\\n return\",\n \"def mutual_information_3d(self,max_lag,percent_calc=.5,digitize=True):\\n\\n if digitize:\\n M = utilities.mi_digitize(self.X)\\n else:\\n M = self.X\\n\\n rs, cs, zs = np.shape(M)\\n\\n rs_iters = int(rs*percent_calc)\\n cs_iters = int(cs*percent_calc)\\n\\n r_picks = np.random.choice(np.arange(rs),size=rs_iters,replace=False)\\n c_picks = np.random.choice(np.arange(cs),size=cs_iters,replace=False)\\n\\n\\n # The r_picks are used to calculate the MI in the columns\\n # and the c_picks are used to calculate the MI in the rows\\n\\n c_mi = np.zeros((rs_iters,max_lag))\\n r_mi = np.zeros((cs_iters,max_lag))\\n\\n for i in range(rs_iters):\\n for j in range(max_lag):\\n\\n rand_z = np.random.randint(0,zs)\\n ind = j+1\\n unshift = M[r_picks[i],ind:,rand_z]\\n shift = M[r_picks[i],:-ind,rand_z]\\n c_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\\n\\n for i in range(cs_iters):\\n for j in range(max_lag):\\n\\n rand_z = np.random.randint(0,zs)\\n ind=j+1\\n unshift = M[ind:, c_picks[i],rand_z]\\n shift = M[:-ind, c_picks[i],rand_z]\\n r_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\\n\\n #for the z dimension\\n rs,cs = np.where(np.random.rand(rs,cs)=2014))\\n\\n dms_cube.var_name = 'field570'\\n dms_cube.attributes.pop('name')\\n dms_cube.coord('time').var_name = 'time'\\n dms_cube.coord('time').long_name = 'time'\\n\\n fut_cube_high = fut_cube_high[:-2]\\n fut_cube_surf = fut_cube_surf[:-2]\\n\\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\\n\\n #Save the final cubes as netcdf (cutting them to be the same length)\\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \\\"SO2DMS_rcp262015.nc\\\")\\n os.system('ncatted -O -a calendar,time,m,c,\\\"360_day\\\" '+data_dir+ \\\"SO2DMS_rcp262015.nc\\\")\\n\\n return\",\n \"def L14_Net112(mode=\\\"train\\\"):\\n data = mx.symbol.Variable(name=\\\"data\\\")\\n landmark_target = mx.symbol.Variable(name=\\\"landmark_target\\\")\\n landmark_vis = mx.symbol.Variable(name=\\\"landmark_vis\\\")\\n \\n # data = 112X112\\n # conv1 = 56X56\\n conv1 = Conv(data, num_filter=res_base_dim, kernel=(3, 3), pad=(1, 1), stride=(2, 2), name=\\\"conv1\\\")\\n conv2 = Residual(conv1, num_block=1, num_out= res_base_dim, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim, name=\\\"res2\\\")\\n \\n\\t#conv23 = 28X28\\n conv23 = DResidual(conv2, num_out=res_base_dim*2, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=res_base_dim*2, name=\\\"dconv23\\\")\\n conv3 = Residual(conv23, num_block=2, num_out=res_base_dim*2, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim*2, name=\\\"res3\\\")\\n \\n\\t#conv34 = 14X14\\n conv34 = DResidual(conv3, num_out=res_base_dim*4, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=res_base_dim*4, name=\\\"dconv34\\\")\\n conv4 = Residual(conv34, num_block=3, num_out=res_base_dim*4, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim*4, name=\\\"res4\\\")\\n \\n\\t#conv45 = 7X7\\n conv45 = DResidual(conv4, num_out=res_base_dim*8, kernel=(3, 3), stride=(2, 2), pad=(1, 1), num_group=res_base_dim*8, name=\\\"dconv45\\\")\\n conv5 = Residual(conv45, num_block=2, num_out=res_base_dim*8, kernel=(3, 3), stride=(1, 1), pad=(1, 1), num_group=res_base_dim*8, name=\\\"res5\\\")\\n \\n\\t# conv6 = 1x1\\n conv6 = Conv(conv5, num_filter=res_base_dim*8, kernel=(7, 7), pad=(0, 0), stride=(1, 1), name=\\\"conv6\\\")\\n fc1 = Conv(conv6, num_filter=res_base_dim*16, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name=\\\"fc1\\\")\\n fc2 = Conv(fc1, num_filter=res_base_dim*32, kernel=(1, 1), pad=(0, 0), stride=(1, 1), name=\\\"fc2\\\")\\t\\n conv6_3 = mx.symbol.FullyConnected(data=fc2, num_hidden=42, name=\\\"conv6_3\\\")\\t\\n bn6_3 = mx.sym.BatchNorm(data=conv6_3, name='bn6_3', fix_gamma=False,momentum=0.9)\\n\\t\\n if mode == \\\"test\\\":\\n landmark_pred = bn6_3\\n group = mx.symbol.Group([landmark_pred])\\n else:\\n \\n out = mx.symbol.Custom(landmark_vis = landmark_vis, landmark_pred=bn6_3, landmark_target=landmark_target, \\n op_type='negativemining_hand21', name=\\\"negative_mining\\\")\\n group = mx.symbol.Group([out])\\n \\n return group\",\n \"def calculate(self, inputs):\\r\\n output = inputs\\r\\n for layer in self.layers:\\r\\n output = layer.calculate(output)\\r\\n return output\",\n \"def calculate_correlations(input_data, index_col, cat_features, exclu_elements): \\r\\n try:\\r\\n # encode the categorical features\\r\\n encoded_data = pd.get_dummies(input_data,columns=cat_features,drop_first=True)\\r\\n\\r\\n pd_transposed_data = encoded_data.set_index('Style_display_code').T\\r\\n\\r\\n # get the number of items\\r\\n items_list = [str(a) for a in pd_transposed_data.columns]\\r\\n\\r\\n print(\\\"Number of items to correlate :{}_Timestamp:{}\\\".format(str(len(items_list)), \\r\\n format(str(datetime.now()))))\\r\\n \\r\\n\\r\\n #compute correlations and save the pickle file\\r\\n# matrix = pd_transposed_data.corr().values\\r\\n# pickle.dump(matrix, open(staging_dir+ '/corr_matrix_output_py3.p', 'wb'))\\r\\n \\r\\n # read from the saved pickle file - ONLY FOR CONSECUTIVE RUNS, TO SAVE TIME\\r\\n matrix = pickle.load(open(staging_dir+ '/corr_matrix_output_py3.p', \\\"rb\\\" ) )\\r\\n\\r\\n print(\\\"Corr Matrix size:{}_Timestamp:{}\\\".format(str(matrix.size),\\r\\n format(str(datetime.now()))))\\r\\n\\r\\n except Exception as e:\\r\\n print(\\\" Error !!\\\", e)\\r\\n \\r\\n # return the top correlated items\\r\\n return top_correlateditems(items_list,matrix, index_col, exclu_elements)\",\n \"def CVNeuralNetLayers(\\n theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires\\n):\\n\\n wires = Wires(wires)\\n repeat = _preprocess(\\n theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires\\n )\\n\\n for l in range(repeat):\\n\\n Interferometer(theta=theta_1[l], phi=phi_1[l], varphi=varphi_1[l], wires=wires)\\n\\n r_and_phi_r = qml.math.stack([r[l], phi_r[l]], axis=1)\\n broadcast(unitary=Squeezing, pattern=\\\"single\\\", wires=wires, parameters=r_and_phi_r)\\n\\n Interferometer(theta=theta_2[l], phi=phi_2[l], varphi=varphi_2[l], wires=wires)\\n\\n a_and_phi_a = qml.math.stack([a[l], phi_a[l]], axis=1)\\n broadcast(unitary=Displacement, pattern=\\\"single\\\", wires=wires, parameters=a_and_phi_a)\\n\\n broadcast(unitary=Kerr, pattern=\\\"single\\\", wires=wires, parameters=k[l])\",\n \"def create(self):\\n \\n \\\"\\\"\\\" A solo prepressing reduction network in the head \\\"\\\"\\\"\\n print(\\\"pre_reduction\\\")\\n with tf.name_scope('pre_reduction'):\\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\\n \\n \\\"\\\"\\\" 1st inception layer group \\\"\\\"\\\"\\n print(\\\"icp1\\\")\\n with tf.name_scope('icp1'):\\n # branch 0\\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\\n # branch 1\\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\\n # branch 2\\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\\n # branch 3\\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\\n # concat\\n icp2_in = NW.concat([icp1_out0,\\n icp1_out1,\\n icp1_out2,\\n icp1_out3], 3, 'icp2_in')\\n\\n \\\"\\\"\\\" 2nd inception layer group \\\"\\\"\\\"\\n print(\\\"icp2\\\")\\n with tf.name_scope('icp2'):\\n # branch 0\\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\\n # branch 1\\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\\n # branch 2\\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\\n # branch 3\\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\\n # concat\\n icp2_out = NW.concat([icp2_out0,\\n icp2_out1,\\n icp2_out2,\\n icp2_out3], 3, 'icp2_out')\\n \\n \\\"\\\"\\\" 3rd inception layer group \\\"\\\"\\\"\\n print(\\\"icp3\\\")\\n with tf.name_scope('icp3'):\\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\\n # branch 0\\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\\n # branch 1\\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\\n # branch 2\\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\\n # branch 3\\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\\n # concat\\n icp3_out = NW.concat([icp3_out0,\\n icp3_out1,\\n icp3_out2,\\n icp3_out3], 3, 'icp3_out')\\n \\n \\\"\\\"\\\" 1st classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls1'):\\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\\n self.layers[\\\"cls1_fc_pose_xy\\\"] = cls1_fc_pose_xy\\n self.layers[\\\"cls1_fc_pose_ab\\\"] = cls1_fc_pose_ab\\n \\n \\\"\\\"\\\" 4st inception layer group \\\"\\\"\\\"\\n print(\\\"icp4\\\")\\n with tf.name_scope('icp4'):\\n # branch 0\\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\\n # branch 1\\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\\n # branch 2\\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\\n # branch 3\\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\\n # concat\\n icp4_out = NW.concat([icp4_out0,\\n icp4_out1,\\n icp4_out2,\\n icp4_out3],3, name='icp4_out')\\n\\n \\\"\\\"\\\" 5st inception layer group \\\"\\\"\\\"\\n print(\\\"icp5\\\")\\n with tf.name_scope('icp5'):\\n # branch 0\\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\\n # branch 1\\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\\n # branch 2\\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\\n # branch 3\\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\\n # concat\\n icp5_out = NW.concat([icp5_out0, \\n icp5_out1, \\n icp5_out2, \\n icp5_out3], 3, name='icp5_out')\\n \\n \\\"\\\"\\\" 6st inception layer group \\\"\\\"\\\"\\n print(\\\"icp6\\\")\\n with tf.name_scope('icp6'):\\n # branch 0\\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\\n # branch 1\\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\\n # branch 2\\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\\n # branch 3\\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\\n # concat\\n icp6_out = NW.concat([icp6_out0,\\n icp6_out1,\\n icp6_out2,\\n icp6_out3], 3, name='icp6_out')\\n\\n \\\"\\\"\\\" 2nd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls2'):\\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\\n self.layers[\\\"cls2_fc_pose_xy\\\"] = cls2_fc_pose_xy\\n self.layers[\\\"cls2_fc_pose_ab\\\"] = cls2_fc_pose_ab\\n\\n \\\"\\\"\\\" 7st inception layer group \\\"\\\"\\\"\\n print(\\\"icp7\\\")\\n with tf.name_scope('icp7'):\\n # branch 0\\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\\n # branch 1\\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\\n # branch 2\\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\\n # branch 3\\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\\n # concat\\n icp7_out = NW.concat([icp7_out0,\\n icp7_out1,\\n icp7_out2,\\n icp7_out3], 3, name='icp7_out')\\n\\n \\\"\\\"\\\" 8st inception layer group \\\"\\\"\\\"\\n print(\\\"icp8\\\")\\n with tf.name_scope('icp8'):\\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\\n # branch 0\\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\\n # branch 1\\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\\n # branch 2\\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\\n # branch 3\\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\\n # concat\\n icp8_out = NW.concat([icp8_out0,\\n icp8_out1,\\n icp8_out2,\\n icp8_out3], 3, name='icp8_out')\\n \\n \\\"\\\"\\\" 9st inception layer group \\\"\\\"\\\"\\n print(\\\"icp9\\\")\\n with tf.name_scope('icp9'):\\n # branch 0\\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\\n # branch 1\\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\\n # branch 2\\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\\n # branch 3\\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\\n # concat\\n icp9_out = NW.concat([icp9_out0,\\n icp9_out1,\\n icp9_out2,\\n icp9_out3], 3, name='icp9_out')\\n\\n \\\"\\\"\\\" 3rd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls3'):\\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\\n self.layers[\\\"cls3_fc_pose_xy\\\"] = cls3_fc_pose_xy\\n self.layers[\\\"cls3_fc_pose_ab\\\"] = cls3_fc_pose_ab\",\n \"def forward(self, img):\\n device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\\n H, W = img.size()[2], img.size()[3]\\n #print('x',x)\\n #print('x.shape',x.shape) ## 32 x 3 x 96 x 128\\n z32 = self.start(img)\\n z64 = self.layer1(z32) + self.layer1_ds(z32)\\n #print('z1',z64.shape)\\n z128 = self.layer2(z64) + self.layer2_ds(z64)\\n #print('z2',z128.shape)\\n z256 = self.layer3(z128) + self.layer3_ds(z128)\\n #print('z3',z256.shape)\\n z256d = self.drop_out_layer(z256)\\n #print('z_drop',z256d.shape)\\n z256u = self.layer4(z256d)\\n #print('z4',z256u.shape)\\n z128u = self.layer5(torch.cat((z256u, F.interpolate(z256d,size=z256u.size()[2:] )), 1))\\n #print('z5',z128u.shape)\\n z64u = self.layer6(torch.cat((z128u, F.interpolate(z128,size=z128u.size()[2:] )), 1))\\n #print('z6',z64u.shape)\\n\\n z32u = self.final(torch.cat((z64u, F.interpolate(z64,size=z64u.size()[2:] )), 1))\\n #print('z6_plus',z32u.shape)\\n\\n #print('z7_result',self.classifer(z32u)[:, :, :H, :W].shape)\\n result_class = self.classifer(z32u)[:, :, :H, :W]\\n\\n #print('model result shape',result_class.shape)\\n ## 16 x 1 x 300 x 400\\n\\n # using soft argmax\\n spa_argmax = spatial_argmax(torch.squeeze(result_class,1))\\n\\n #one hot with spatial argmax\\n #xy_val = torch.zeros(spa_argmax.shape).float()\\n #for idx, pt in enumerate(spa_argmax):\\n # x_val = (pt[0]+1.0)*63.5\\n # y_val = (pt[1]+1.0)*47.5\\n # # for each batch. [0...127][0...95]\\n # xy_val[idx][0] = x_val\\n # xy_val[idx][1] = y_val\\n\\n xy_val = (spa_argmax+1.0).to(device)\\n #print('spa_argmax',spa_argmax)\\n scaling_factor = torch.FloatTensor([[(W-1)/2,0.],[0.,(H-1)/2]]).to(device)\\n #scaling_factor = torch.FloatTensor([[63.5,0.],[0.,44.5]]).to(device)\\n xy_val = xy_val.mm(scaling_factor)\\n\\n return xy_val\",\n \"def method3(self):\\n cres=0.\\n Ux_aloc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy_aloc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.ALDM[ix ,iy, : , : ]\\n mat2=self.ALDM[(ix%self.kS.Nx)+1, iy, : , : ]\\n mat3=self.ALDM[ix ,(iy%self.kS.Ny)+1, : , : ]\\n \\n Ux_aloc[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[self.NL-1:,self.NL-1:])\\n Uy_aloc[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[self.NL-1:,self.NL-1:])\\n\\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux_aloc[ix,iy]*Uy_aloc[ix+1,iy]/Ux_aloc[ix,iy+1]/Uy_aloc[ix,iy])\\n cres+=ftemp/2./pi/1j\\n \\n return cres.real\\n #End of method3\",\n \"def learn(self):\\r\\n \\r\\n # unpack\\r\\n X = self.Train.X\\r\\n Y = self.Train.Y\\r\\n DY = self.Train.DY\\r\\n \\r\\n NX ,ND = X.shape\\r\\n NDY,_ = DY.shape\\r\\n \\r\\n print 'Build Information Matricies ...'\\r\\n \\r\\n # functions\\r\\n ay0 = np.array([[1.]]*NX)\\r\\n ay1 = X\\r\\n ay2 = np.reshape( np.einsum('ij,ik->ijk',X,X) , [-1,ND*ND] )\\r\\n\\r\\n # reduce redundant basis variables\\r\\n i_doub = np.tri(ND,k=-1).T == 1\\r\\n ay2[:,i_doub.ravel()] = ay2[:,i_doub.ravel()] * 2. \\r\\n i_keep = np.tri(ND,k=0).T == 1\\r\\n ay2 = ay2[:,i_keep.ravel()]\\r\\n\\r\\n # basis matrix, functions\\r\\n Ay = np.hstack([ay0,ay1,ay2])\\r\\n \\r\\n # arrays for the least squares regression\\r\\n At = Ay\\r\\n Yt = Y\\r\\n \\r\\n # gradients\\r\\n if NDY:\\r\\n ad0 = np.array([[0.]]*NX*ND)\\r\\n \\r\\n ad1 = np.tile( np.eye(ND) , [NX,1] )\\r\\n \\r\\n ad2a = np.repeat( np.eye(ND)[:,None,:] , ND , 1 )\\r\\n ad2a = np.reshape( ad2a , [-1,ND*ND] ) \\r\\n ad2a = np.repeat( ad2a, NX, axis=0 ) * np.repeat( np.tile( X, [ND,1] ) , ND, axis=1 )\\r\\n \\r\\n ad2b = np.repeat( np.eye(ND)[:,:,None] , ND , 2 )\\r\\n ad2b = np.reshape( ad2b , [-1,ND*ND] ) \\r\\n ad2b = np.repeat( ad2b, NX, axis=0 ) * np.tile( np.tile( X, [ND,1] ) , [1,ND] )\\r\\n \\r\\n ad2 = ad2a + ad2b\\r\\n \\r\\n # reduce redundant bases\\r\\n ad2[:,i_doub.ravel()] = ad2[:,i_doub.ravel()] * 2.\\r\\n ad2 = ad2[:,i_keep.ravel()] \\r\\n \\r\\n Ad = np.hstack([ad0,ad1,ad2])\\r\\n \\r\\n # add to arrays for least squares regression\\r\\n At = np.vstack([At,Ad])\\r\\n Yt = np.vstack([Yt, np.ravel(DY.T)[:,None]])\\r\\n \\r\\n print 'Least Squares Solve ...'\\r\\n B = sp.linalg.lstsq(At,Yt)[0] \\r\\n \\r\\n # unpack data\\r\\n c = B[0,0]\\r\\n b = B[1:ND+1]\\r\\n \\r\\n A = np.zeros([ND,ND])\\r\\n A[i_keep] = B[ND+1:,0]\\r\\n A[i_keep.T] = A.T[i_keep.T]\\r\\n \\r\\n # problem forumulation\\r\\n A = A*2.\\r\\n \\r\\n # store results\\r\\n self.c = c\\r\\n self.b = b\\r\\n self.A = A\\r\\n \\r\\n print ''\",\n \"def neuron_stats_to_layer(neuron_info, input_layer_count, input_neurons_per_layer, network_info, target_column=\\\"synapse_count\\\"):\\n # assuming the first neuron in neuron\\n input_layer = list()\\n\\n input_neuron_ids = neuron_info[ neuron_info.ids < 0].ids.values - np.min(neuron_info.ids)\\n input_neuron_values = neuron_info[ neuron_info.ids < 0][target_column]\\n\\n input_collector = np.zeros((input_layer_count, input_neurons_per_layer))\\n\\n for inp_l in range(input_layer_count):\\n mask_above_first = inp_l * input_neurons_per_layer <= input_neuron_ids\\n below_last = input_neuron_ids < (inp_l + 1 ) * input_neurons_per_layer\\n\\n mask = mask_above_first & below_last\\n\\n ids_for_this_layer = input_neuron_ids[mask] - inp_l * input_neurons_per_layer\\n\\n input_collector[inp_l, ids_for_this_layer] = input_neuron_values[mask]\\n\\n # now the normal layers\\n normal_neuron_info = neuron_info[ neuron_info.ids >= 0]\\n\\n\\n exc_collector = np.zeros((network_info[\\\"num_layers\\\"], network_info[\\\"num_exc_neurons_per_layer\\\"]))\\n inh_collector = np.zeros((network_info[\\\"num_layers\\\"], network_info[\\\"num_inh_neurons_per_layer\\\"]))\\n\\n layerwise = helper.split_into_layers(normal_neuron_info, network_info)\\n for l_id, layer in enumerate(layerwise):\\n exc, inh = helper.split_exc_inh(layer, network_info)\\n exc_collector[l_id, exc.ids] = exc[target_column].values\\n inh_collector[l_id, inh.ids] = inh[target_column].values\\n\\n return input_collector, exc_collector, inh_collector\",\n \"def method2(self):\\n cres=np.zeros(self.NL,dtype=float) # List of invariants\\n # The U matrices from Fukui's method; storage...\\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n for il in range(self.NL):\\n # ... and calculation of U matrices for each layer\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.LDM[il,ix ,iy ,:,:]\\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\\n \\n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\\n \\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\\n \\n return cres\",\n \"def mutual_information_spatial(self,max_lag,percent_calc=.5,digitize=True):\\n if digitize:\\n M = utilities.mi_digitize(self.X)\\n else:\\n M = self.X\\n\\n rs, cs = np.shape(M)\\n\\n rs_iters = int(rs*percent_calc)\\n cs_iters = int(cs*percent_calc)\\n\\n r_picks = np.random.choice(np.arange(rs),size=rs_iters,replace=False)\\n c_picks = np.random.choice(np.arange(cs),size=cs_iters,replace=False)\\n\\n\\n # The r_picks are used to calculate the MI in the columns\\n # and the c_picks are used to calculate the MI in the rows\\n\\n c_mi = np.zeros((rs_iters,max_lag))\\n r_mi = np.zeros((cs_iters,max_lag))\\n\\n for i in range(rs_iters):\\n for j in range(max_lag):\\n\\n ind = j+1\\n unshift = M[r_picks[i],ind:]\\n shift = M[r_picks[i],:-ind]\\n c_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\\n\\n for i in range(cs_iters):\\n for j in range(max_lag):\\n\\n ind=j+1\\n unshift = M[ind:, c_picks[i]]\\n shift = M[:-ind, c_picks[i]]\\n r_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\\n\\n r_mut = np.mean(r_mi,axis=0)\\n c_mut = np.mean(c_mi,axis=0)\\n\\n return r_mut, c_mut, r_mi, c_mi\",\n \"def cminfo_compute():\\n from hera_mc import cm_sysutils \\n h = cm_sysutils.Handling()\\n cminfo = h.get_cminfo_correlator()\\n snap_to_ant = {}\\n ant_to_snap = {}\\n for antn, ant in enumerate(cminfo['antenna_numbers']):\\n name = cminfo['antenna_names'][antn]\\n for pol in cminfo['correlator_inputs'][antn]:\\n if pol.startswith('e'):\\n e_pol = pol\\n if pol.startswith('n'):\\n n_pol = pol\\n ant_to_snap[ant] = {}\\n if e_pol != 'None':\\n snapi_e, channel_e = snap_part_to_host_input(cminfo['correlator_inputs'][antn][0])\\n ant_to_snap[ant]['e'] = {'host': snapi_e, 'channel': channel_e}\\n if snapi_e not in snap_to_ant.keys():\\n snap_to_ant[snapi_e] = [None] * 6\\n snap_to_ant[snapi_e][channel_e] = name + 'E'\\n if n_pol != 'None':\\n snapi_n, channel_n = snap_part_to_host_input(cminfo['correlator_inputs'][antn][1])\\n ant_to_snap[ant]['n'] = {'host': snapi_n, 'channel': channel_n}\\n if snapi_n not in snap_to_ant.keys():\\n snap_to_ant[snapi_n] = [None] * 6\\n snap_to_ant[snapi_n][channel_n] = name + 'N'\\n return snap_to_ant, ant_to_snap\",\n \"def forward(self, images):\\n features = self.resnet(images)\\n features = Variable(features.data)\\n features = self.pooling(features)\\n # print(features)\\n features = features.view(features.size(0),-1)\\n # print(features)\\n # print(resnet.fc.in_features)\\n features = self.bn(self.linear(features))\\n return features\\n # with torch.no_grad():\\n # features = self.resnet(images)\\n # features = features.reshape(features.size(0), -1)\\n # features = self.bn(self.linear(features))\\n # return features\",\n \"def forward(self, x):\\n for name, module in self.base._modules.items():\\n if name == 'avgpool':\\n break\\n\\n if name == 'layer3':\\n l2 = Variable(x)\\n\\n x = Variable(module(x))\\n l4 = Variable(x)\\n\\n \\\"\\\"\\\"for name, param in self.base.named_parameters():\\n print(name, param.size())\\n\\n res50_model = self.base\\n res50_conv2 = ResNet50Bottom(res50_model)\\n for i,child in enumerate(self.base.children()):\\n print(i)\\n if i==8:\\n l4=x\\n break\\n if i==6:\\n l2=x\\n x=res50_conv2(x.detach())\\\"\\\"\\\"\\n\\n s2 = l2.sum(1) #/ 100\\n #\\n s4 = l4.sum(1) #/ 1000\\n\\n\\n sw2 = s2 / (s2.view(x.size(0), -1).sum(1)).unsqueeze(1).unsqueeze(2)\\n\\n sw4 = s4 / (s4.view(x.size(0), -1).sum(1)).unsqueeze(1).unsqueeze(2)\\n\\n\\n l2 = l2 * sw2.unsqueeze(1)\\n l4 = l4 * sw4.unsqueeze(1)\\n\\n \\n c2 = self.inconv2(l2)\\n c4 = self.inconv4(l4)\\n c2 = self.bn2(c2)\\n c4 = self.bn4(c4)\\n \\n n2 = F.softmax(torch.mean(torch.mean(c2, dim=2), dim=2), dim=1)\\n n4 = F.softmax(torch.mean(torch.mean(c4, dim=2), dim=2), dim=1)\\n nn2 = n2.data.cpu().numpy()\\n nn4 = n4.data.cpu().numpy()\\n cam2 = np.zeros((x.size(0), 28, 28), dtype=float)\\n cam4 = np.zeros((x.size(0), 7, 7), dtype=float)\\n\\n\\n for i in range(0, x.size(0)):\\n for j in range(0, 2):\\n temp1 = c2[i, j, :, :].data.cpu().numpy()\\n temp1 = np.maximum(temp1, 0)\\n temp1 = temp1 - np.min(temp1)\\n temp1 = temp1 / (np.max(temp1)+1e-8)\\n cam2[i] = cam2[i] + nn2[i, j] * temp1\\n cam2 = torch.FloatTensor(cam2)\\n l2 = l2 * (cam2.unsqueeze(1).cuda())\\n l2 = self.stack1(l2)\\n l2 = self.stack1_1(l2)\\n\\n for i in range(0, x.size(0)):\\n for j in range(0, 8):\\n temp2 = c4[i, j, :, :].data.cpu().numpy()\\n temp2 = np.maximum(temp2, 0)\\n temp2 = temp2 - np.min(temp2)\\n temp2 = temp2 / (np.max(temp2)+1e-8)\\n cam4[i] =cam4[i] + nn4[i, j] * temp2\\n cam4 = torch.FloatTensor(cam4)\\n l4 = l4 * cam4.unsqueeze(1).cuda()\\n l4 = self.stack3(l4)\\n X = l2.view(x.size(0), 512, 7 ** 2)\\n Y = l4.view(x.size(0), 512, 7 ** 2)\\n Z = self.cross_bilinear(X, Y)\\n return n2, n4, Z\",\n \"def processAlgorithm(self, parameters, context, feedback):\\n NO2_present_raster = self.parameterAsRasterLayer(parameters, self.INPUTNP, context)\\n NO2_present_data_source = gdal.Open(NO2_present_raster.dataProvider().dataSourceUri())\\n arr_NO2_present = NO2_present_data_source.GetRasterBand(1).ReadAsArray()\\n\\n PM10_present_raster = self.parameterAsRasterLayer(parameters, self.INPUTPP, context)\\n PM10_present_data_source = gdal.Open(PM10_present_raster.dataProvider().dataSourceUri())\\n arr_PM10_present = PM10_present_data_source.GetRasterBand(1).ReadAsArray()\\n\\n ozono_present_raster = self.parameterAsRasterLayer(parameters, self.INPUTOP, context)\\n ozono_present_data_source = gdal.Open(ozono_present_raster.dataProvider().dataSourceUri())\\n arr_ozono_present = ozono_present_data_source.GetRasterBand(1).ReadAsArray()\\n\\n arr_present = arr_ozono_present + arr_PM10_present + arr_NO2_present\\n\\n NO2_future_raster = self.parameterAsRasterLayer(parameters, self.INPUTNF, context)\\n NO2_future_data_source = gdal.Open(NO2_future_raster.dataProvider().dataSourceUri())\\n arr_NO2_future = NO2_future_data_source.GetRasterBand(1).ReadAsArray()\\n\\n PM10_future_raster = self.parameterAsRasterLayer(parameters, self.INPUTPF, context)\\n PM10_future_data_source = gdal.Open(PM10_future_raster.dataProvider().dataSourceUri())\\n arr_PM10_future = PM10_future_data_source.GetRasterBand(1).ReadAsArray()\\n\\n ozono_future_raster = self.parameterAsRasterLayer(parameters, self.INPUTOF, context)\\n ozono_future_data_source = gdal.Open(ozono_future_raster.dataProvider().dataSourceUri())\\n arr_ozono_future = ozono_future_data_source.GetRasterBand(1).ReadAsArray()\\n\\n arr_future = arr_ozono_future + arr_PM10_future + arr_NO2_future\\n\\n area_pixel = self.parameterAsInt(parameters, self.PIXEL_RES, context) * self.parameterAsInt(\\n parameters, self.PIXEL_RES, context)\\n\\n NO2_euro_coeff = 77641.89\\n ozono_euro_coeff = 14658.11\\n PM10_euro_coeff = 17132.56\\n\\n arr_euro_present_NO2 = arr_NO2_present * NO2_euro_coeff\\n arr_euro_present_ozono = arr_ozono_present * ozono_euro_coeff\\n arr_euro_present_PM10 = arr_PM10_present * PM10_euro_coeff\\n arr_value_present = arr_euro_present_PM10 + arr_euro_present_ozono + arr_euro_present_NO2\\n\\n arr_euro_future_NO2 = arr_NO2_future * NO2_euro_coeff\\n arr_euro_future_ozono = arr_ozono_future * ozono_euro_coeff\\n arr_euro_future_PM10 = arr_PM10_future * PM10_euro_coeff\\n arr_value_future = arr_euro_future_PM10 + arr_euro_future_ozono + arr_euro_future_NO2\\n\\n arr_diff_NO2 = arr_euro_future_NO2 - arr_euro_present_NO2\\n arr_diff_PM10 = arr_euro_future_PM10 - arr_euro_present_PM10\\n arr_diff_ozono = arr_euro_future_ozono - arr_euro_present_ozono\\n\\n arr_diff_tot = arr_diff_NO2 + arr_diff_PM10 + arr_diff_ozono\\n\\n # Initialize and write on output raster\\n path_output = self.parameterAsString(parameters, self.OUTPUT, context)\\n file_output = path_output + '/SE_02_rimozione_inquinanti_delta_euro.tiff'\\n driver = gdal.GetDriverByName(\\\"GTiff\\\")\\n [cols, rows] = arr_NO2_present.shape\\n diff_tot = np.sum(arr_diff_tot) / (cols * rows )\\n outdata = driver.Create(file_output, rows, cols, 1, gdal.GDT_Float64)\\n outdata.SetGeoTransform(NO2_present_data_source.GetGeoTransform()) ##sets same geotransform as input\\n outdata.SetProjection(NO2_present_data_source.GetProjection()) ##sets same projection as input\\n outdata.GetRasterBand(1).WriteArray(arr_diff_tot)\\n print(np.max(outdata.GetRasterBand(1).ReadAsArray()))\\n outdata.FlushCache()\\n\\n # Years\\n present = self.parameterAsInt(parameters, self.INPUTPRE, context)\\n future = self.parameterAsInt(parameters, self.INPUTFUT, context)\\n report_output = path_output + '/SE_rimozione_inquinanti.txt'\\n f = open(report_output, \\\"w+\\\")\\n today = datetime.today().strftime('%Y-%m-%d-%H:%M:%S')\\n f.write(\\\"Sommario dell'analisi della rimozione inquinanti\\\\n\\\")\\n f.write(\\\"Data: \\\" + today +\\\"\\\\n\\\\n\\\\n\\\")\\n f.write(\\\"Analisi stato di fatto\\\\n\\\\n\\\")\\n f.write(\\\"Anno corrente: %i \\\\n\\\" % (present))\\n f.write(\\\"Rimozione NO2 Stato attuale (ton): %f \\\\n\\\" % (np.sum(arr_NO2_present)))\\n f.write(\\\"Rimozione PM10 Stato attuale (ton): %f \\\\n\\\" % (np.sum(arr_PM10_present)))\\n f.write(\\\"Rimozione ozono Stato attuale (ton): %f \\\\n\\\" % (np.sum(arr_ozono_present)))\\n f.write(\\\"Valore totale della rimozione inquinanti (€): %f \\\\n\\\\n\\\\n\\\" % (np.sum(arr_value_present)))\\n f.write(\\\"Analisi stato di progetto\\\\n\\\\n\\\")\\n f.write(\\\"Anno progetto: %i \\\\n\\\" % (future))\\n f.write(\\\"Rimozione NO2 Stato di progetto (ton): %f \\\\n\\\" % (np.sum(arr_NO2_future)))\\n f.write(\\\"Rimozione PM10 Stato di progetto (ton): %f \\\\n\\\" % (np.sum(arr_PM10_future)))\\n f.write(\\\"Rimozione ozono Stato di progetto (ton): %f \\\\n\\\" % (np.sum(arr_ozono_future)))\\n f.write(\\\"Valore totale della rimozione inquinanti (€): %f \\\\n\\\\n\\\\n\\\" % (np.sum(arr_value_future)))\\n f.write(\\\"Differenze tra stato di progetto e stato attuale\\\\n\\\\n\\\")\\n f.write(\\\"Anno progetto: %i - %i\\\\n\\\" % (present, future))\\n f.write(\\\"Differenza della rimozione inquinanti (ton):: %f \\\\n\\\" % (np.sum(arr_future - arr_present)))\\n f.write(\\\"Differenza sequestro inquinanti per unità di superficie (ton/ha): %f \\\\n\\\" % (\\n np.sum(arr_future - arr_present) / (cols * rows * area_pixel) * 10000))\\n f.write(\\\"Differenza in termini economici del SE Rimozione inquinanti (stato di progetto – stato attuale) (€):%d \\\\n\\\" % (\\n np.sum(arr_diff_tot))) \\n return {self.OUTPUT: 'Completed'}\\n\\n \\n # ----------------------------------------------------------------------------------- \\n # Copyright (c) 2021 Città di Torino.\\n # \\n # This material is free software: you can redistribute it and/or modify\\n # it under the terms of the GNU General Public License as published by\\n # the Free Software Foundation, either version 2 of the License, or\\n # (at your option) any later version.\\n # \\n # This program is distributed in the hope that it will be useful,\\n # but WITHOUT ANY WARRANTY; without even the implied warranty of\\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n # GNU General Public License for more details.\\n # \\n # You should have received a copy of the GNU General Public License\\n # along with this program. If not, see http://www.gnu.org/licenses.\\n # ----------------------------------------------------------------------------------- \",\n \"def run(layers):\\n\\n # Value above which people are regarded affected\\n # For this dataset, 0 is no data, 1 is cloud, 2 is normal water level\\n # and 3 is overflow.\\n threshold = 0\\n\\n # Identify hazard and exposure layers\\n inundation = get_hazard_layer(layers)\\n\\n [population] = get_exposure_layers(layers)\\n\\n # Extract data as numeric arrays\\n D = inundation.get_data(nan=0.0) # Depth\\n\\n # Scale the population layer\\n P = population.get_data(nan=0.0, scaling=True)\\n I = numpy.where(D > threshold, P, 0)\\n\\n # Assume an evenly distributed population for Gender\\n G = 0.5\\n pregnant_ratio = 0.024 # 2.4% of women are estimated to be pregnant\\n\\n # Calculate breakdown\\n P_female = P * G\\n P_male = P - P_female\\n P_pregnant = P_female * pregnant_ratio\\n\\n I_female = I * G\\n I_male = I - I_female\\n I_pregnant = I_female * pregnant_ratio\\n\\n # Generate text with result for this study\\n total = str(int(sum(P.flat) / 1000))\\n count = str(int(sum(I.flat) / 1000))\\n\\n total_female = str(int(sum(P_female.flat) / 1000))\\n total_male = str(int(sum(P_male.flat) / 1000))\\n total_pregnant = str(int(sum(P_pregnant.flat) / 1000))\\n\\n affected_female = str(int(sum(I_female.flat) / 1000))\\n affected_male = str(int(sum(I_male.flat) / 1000))\\n affected_pregnant = str(int(sum(I_pregnant.flat) / 1000))\\n\\n # Create raster object and return\\n R = Raster(I,\\n projection=inundation.get_projection(),\\n geotransform=inundation.get_geotransform(),\\n name='People affected',\\n keywords={'total': total, 'count': count,\\n 'total_female': total_female, 'affected_female': affected_female,\\n 'total_male': total_male, 'affected_male': affected_male,\\n 'total_pregnant': total_pregnant, 'affected_pregnant': affected_pregnant,\\n })\\n return R\",\n \"def three_layer_neuralnetwork(X, model, y=None, reg=0.0,verbose=0):\\n \\n # Unpack weights\\n W1, b1, W2, b2, W3, b3 = model['W1'], model['b1'], model['W2'], model['b2'],model['W3'],model['b3']\\n N,D= X.shape\\n\\n assert W1.shape[0] == D, ' W1 2nd dimenions must match number of features'\\n \\n dW1,dW2,dW3,db1,db2,db3=np.zeros_like(W1),np.zeros_like(W2),np.zeros_like(W3),np.zeros_like(b1),np.zeros_like(b2),np.zeros_like(b3)\\n # Compute the forward pass\\n \\n '''\\n AffineLayer = X.dot(W1)+b1 \\n ReluLayer,_ = relu_forward(AffineLayer)\\n AffineLayer2 = ReluLayer.dot(W2) + b2\\n ReluLayer2,_ = relu_forward(AffineLayer2)\\n AffineLayer3 = ReluLayer2.dot(W3) + b3\\n scores = AffineLayer3\\n \\n print X.shape\\n print W1.shape\\n print b1.shape\\n print W2.shape\\n print b2.shape\\n print W3.shape\\n print b3.shape\\n '''\\n affine_out1,cache1 = affine_forward(X, W1, b1)\\n relu_out1,cache_relu1 = relu_forward(affine_out1)\\n \\n affine_out2,cache2 = affine_forward(relu_out1, W2, b2)\\n relu_out2,cache_relu2 = relu_forward(affine_out2)\\n \\n affine_out3,cache3 = affine_forward(relu_out2, W3, b3)\\n scores = affine_out3\\n\\n #if verbose:\\n #print ['Layer {} Variance = {}'.format(i+1, np.var(l[:])) for i,l in enumerate([a1, a2, cache3[0]])][:]\\n if y is None:\\n return scores\\n data_loss,d_softmax = softmax_loss(scores,y)\\n data_loss += reg * (np.sum(W1*W1) + np.sum(W2*W2) + np.sum(W3*W3))\\n '''\\n max_scores = np.max(scores)\\n scores -= max_scores\\n correct_class_scores = scores[y,np.arange(N)]\\n exp_score = np.exp(scores)\\n sumexp = np.sum(exp_score,axis=0)\\n loss_i = -correct_class_scores + np.log(sumexp)\\n loss = np.sum(loss_i) / N \\n ''' \\t\\n # Compute the backward pass\\n \\n d_affine_out3, dW3, db3 = affine_backward(d_softmax, cache3) \\n d_relu2 = relu_backward(d_affine_out3, cache_relu2)\\n \\n d_affine_out2, dW2, db2 = affine_backward(d_relu2, cache2) \\n d_relu1 = relu_backward(d_affine_out2, cache_relu1)\\n \\n d_affine_out1, dW1, db1 = affine_backward(d_relu1, cache1) \\n \\n #\\n reg_loss = 0\\n\\n loss = data_loss + reg_loss\\n grads = {'W1': dW1, 'b1': db1, 'W2': dW2, 'b2': db2,'W3':dW3,'b3':db3}\\n \\n return loss, grads\",\n \"def optimize_correlation(self,dataloader,num_epochs=10, optimizer=None):\\n print(\\\" Start Correlation optimizing...\\\")\\n if optimizer is None:\\n optimizer = optim.SGD(self.parameters(),lr=0.001,momentum=0.9)\\n loss_sub_log = []\\n for epoch in range(num_epochs):\\n current_loss = float(0)\\n # batch_num = 0\\n for batch_idx, batch_data in enumerate(dataloader,start=0):\\n data, labels = batch_data\\n optimizer.zero_grad()\\n forward_correlation_result = F.softmax(self.forward(data),dim=1)\\n # labels_extended = labels.expand(forward_correlation_result.shape)\\n labels_extended = torch.zeros(forward_correlation_result.shape)\\n for idx, label in enumerate(labels):\\n labels_extended[idx][label] = 1\\n\\n error = forward_correlation_result-labels_extended\\n # print(forward_correlation_result[0])\\n # print(labels_extended[0])\\n # print(labels[0])\\n loss = -correlation_loss(self.latest_hidden_out,error)\\n loss.backward()\\n optimizer.step()\\n current_loss = loss.item()\\n # batch_num+=1\\n loss_sub_log.append(current_loss)\\n print(f\\\" sub epoch {epoch} correlation loss: {-current_loss}\\\")\\n\\n return optimizer\",\n \"def get_final_reconstruction(self):\",\n \"def transformation(self):\\n for key in self.combination_dict.keys():\\n if self.combination_dict[key]['column_count'] == 2:\\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'tem' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'tem':\\n self.temporal_transformation(self.combination_dict[key])\\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'cat' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'cat':\\n self.categorical_transformation(self.combination_dict[key])\\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num' and self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\\n self.numerical_transformation(self.combination_dict[key])\\n\\n elif self.combination_dict[key]['column_count'] == 3:\\n num_count = 0\\n num_column = []\\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(0)\\n elif self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(1)\\n elif self.data_dict[self.combination_dict[key]['column3']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(2)\\n\\n if num_count == 1:\\n self.three_column_groupby_logic(self.combination_dict[key], num_column)\\n\\n m_score_pie = []\\n m_score_bar = []\\n m_score_line = []\\n m_score_scatter = []\\n # for key in self.scenario_dict:\\n # if self.scenario_dict\\n for key in self.scenario_dict:\\n if math.isnan(self.scenario_dict[key][\\\"Scatter_chart_score\\\"]):\\n m_score_scatter.append(0)\\n else:\\n m_score_scatter.append(self.scenario_dict[key][\\\"Scatter_chart_score\\\"])\\n m_score_pie.append(self.scenario_dict[key][\\\"Pie_chart_score\\\"])\\n m_score_bar.append(self.scenario_dict[key][\\\"Bar_chart_score\\\"])\\n m_score_line.append(self.scenario_dict[key][\\\"Line_chart_score\\\"])\\n\\n m_score_pie /= np.max(m_score_pie)\\n m_score_bar /= np.max(m_score_bar)\\n m_score_line /= np.max(m_score_line)\\n m_score_scatter /= np.max(m_score_scatter)\\n m_score = [m_score_pie, m_score_bar, m_score_line, m_score_scatter]\\n match_index = np.argmax(m_score, axis = 0)\\n i = 0\\n for key in self.scenario_dict:\\n if match_index[i] == 0:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"pie\\\"\\n if match_index[i] == 1:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"bar\\\"\\n if match_index[i] == 2:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"line\\\"\\n if match_index[i] == 3:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"scatter\\\"\\n self.scenario_dict[key][\\\"m_score\\\"] = m_score[match_index[i]][i]\\n i += 1\\n\\n return self.scenario_dict\",\n \"def MR1():\\n global CO1_OUTPUT, MR1_OUTPUT\\n\\n for b in range(MR1_OB):\\n for f in range(MR1_OF):\\n # Maxpool begins here\\n for r in range(MR1_OR):\\n for c in range(MR1_OC):\\n frame = np.zeros(4)\\n frame[0] = CO1_OUTPUT[b][f][r*2 ][c*2 ]\\n frame[1] = CO1_OUTPUT[b][f][r*2+1][c*2 ]\\n frame[2] = CO1_OUTPUT[b][f][r*2 ][c*2+1]\\n frame[3] = CO1_OUTPUT[b][f][r*2+1][c*2+1]\\n\\n # ReLU begins here\\n maximum = 0\\n for i in range(4):\\n if frame[i] > maximum:\\n maximum = frame[i]\\n\\n MR1_OUTPUT[b][f][r][c] = maximum\",\n \"def calculate_output(self):\",\n \"def pca_reduction(X, ncomp=20):\\n print('Performing dimensionality reduction ...')\\n\\n # PCA fitting\\n pca = PCA(n_components=ncomp)\\n weights = pca.fit_transform(X)\\n basis = pca.components_\\n\\n # # Plot cumsum(explained_variance) versus component\\n # plt.semilogy(pca.explained_variance_ratio_*100, 's')\\n # plt.ylabel('Explained Variance Ratio (%)', size=20)\\n # plt.xticks(size=20)\\n # plt.xlabel('Component', size=20)\\n # plt.yticks(size=20)\\n # plt.show()\\n\\n print('Explained variance ratio : '+str(round(np.cumsum(pca.explained_variance_ratio_)[-1]*100, 2))+' %.')\\n\\n # pickle.dump(pca, '/../Data/GPmodel/pca_'+str(ncomp))\\n\\n # Some plots on PCA\\n # plot_pca(basis, weights)\\n\\n return pca, weights\",\n \"def residmapComparison():\\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\\n\\n image_data = fits.getdata('dataFiles/6gev_image.fits')\\n filename = get_pkg_data_filename('dataFiles/6gev_image.fits')\\n hdu = fits.open(filename)[0]\\n wcs = WCS(hdu.header)\\n\\n #Given the results of the fit, calculate the model\\n modelData001 = np.zeros(srcmap001[0].shape)\\n modelData03 = np.zeros(srcmap03[0].shape)\\n\\n file = open('plotsData/fitResults001.pk1','rb')\\n fit001 = pickle.load(file)\\n file.close()\\n\\n file = open('plotsData/fitResults03.pk1','rb')\\n fit03 = pickle.load(file)\\n file.close()\\n\\n\\n for source in fit001:\\n the_index = srcmap001.index_of(source)\\n\\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\\n for source in fit03:\\n the_index = srcmap03.index_of(source)\\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\\n\\n fig = plt.figure(figsize=[12, 4.5])\\n\\n vmin = -25.0\\n vmax = 25.0\\n cbStep = 5.0\\n ax = fig.add_subplot(121, projection=wcs)\\n ax=plt.gca()\\n ax.tick_params(direction='in')\\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\\n ax.add_patch(c)\\n mappable=plt.imshow((image_data-np.sum(modelData001,axis=0)),cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')#\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Point Source ($>6$ GeV)')\\n cb = plt.colorbar(mappable, label='Residual counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb.ax.tick_params(width=0)\\n\\n\\n ax2=fig.add_subplot(122, projection=wcs)\\n ax2 = plt.gca()\\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\\n ax2.add_patch(c2)\\n mappable2 = plt.imshow((image_data-np.sum(modelData03,axis=0)), cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Extended Source ($>6$ GeV)')\\n cb2 = plt.colorbar(mappable2, label='Residual counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb2.ax.tick_params(width=0)\\n fig.tight_layout()\\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\\n #plt.savefig('plots/residComparison.pdf',bbox_inches='tight')\\n plt.show()\",\n \"def __update(self):\\n\\n # Make sure loads have been assigned to group\\n if type(self.appliedLoad) == Load:\\n self.appliedLoad = LoadSet(self.appliedLoad)\\n elif type(self.appliedLoad) != LoadSet:\\n raise TypeError(\\\"Applied load must be a Load or LoadSet\\\")\\n\\n # Begin Calculations\\n _cg = self.cg # calculate the cg once to save computation time\\n _appLoad = self.appliedLoad.totalForce\\n _appMoment = self.appliedLoad.totalMoment\\n\\n coef_mat = np.zeros((len(self) * 3, len(self) * 3)) # coeff matrix\\n soln_mat = np.zeros(len(self) * 3) # solution matrix\\n\\n cSet = [[i, i+1, i+2] for i in range(0, 3 * len(self), 3)]\\n rSet = [[i+6, i+7, i+8] for i in range(0, 3 * (len(self) - 2), 3)]\\n\\n for i, j in enumerate(cSet):\\n # i = column fastener ID\\n # j = column fastener set\\n # Mx = yFz - zFy\\n # My = zFx - xFz\\n # Mz = xFy - yFx\\n\\n Fx = j[0]\\n Fy = j[1]\\n Fz = j[2]\\n\\n # fill in first three rows\\n coef_mat[0][Fx] = 1 # sum of Fx\\n coef_mat[1][Fy] = 1 # sum of Fy\\n coef_mat[2][Fz] = 1 # sum of Fz\\n\\n # fill in fourth row (sum of Mx at CG)\\n coef_mat[3][Fy] = -(F[i].xyz[2] - _cg[2]) # -zFy\\n coef_mat[3][Fz] = +(F[i].xyz[1] - _cg[1]) # +yFz\\n\\n # fill in fifth row (sum of My at CG)\\n coef_mat[4][Fx] = +(F[i].xyz[2] - _cg[2]) # +zFx\\n coef_mat[4][Fz] = -(F[i].xyz[0] - _cg[0]) # -xFz\\n\\n # fill in sixth row (sum of Mz at CG)\\n coef_mat[5][Fx] = -(F[i].xyz[1] - _cg[1]) # -yFx\\n coef_mat[5][Fy] = +(F[i].xyz[0] - _cg[0]) # +xFy\\n\\n for u, w in enumerate(rSet):\\n # u = row fastener ID\\n # w = row fastener set\\n\\n rX = w[0]\\n rY = w[1]\\n rZ = w[2]\\n\\n coef_mat[rX][Fy] = -(F[i].xyz[2] - F[u].xyz[2]) # -zFy\\n coef_mat[rX][Fz] = +(F[i].xyz[1] - F[u].xyz[1]) # +yFz\\n\\n coef_mat[rY][Fx] = +(F[i].xyz[2] - F[u].xyz[2]) # +zFx\\n coef_mat[rY][Fz] = -(F[i].xyz[0] - F[u].xyz[0]) # -xFz\\n\\n coef_mat[rZ][Fx] = -(F[i].xyz[1] - F[u].xyz[1]) # -yFx\\n coef_mat[rZ][Fy] = +(F[i].xyz[0] - F[u].xyz[0]) # +xFy\\n\\n # fill in the solution matrix (soln_mat)\\n for i in range(3):\\n soln_mat[i] = -_netLoad.force[i]\\n soln_mat[i+3] = -_netLoad.moment[i]\\n\\n # fill in the remaining rows\\n for i, j in enumerate(rSet):\\n # i = fastener\\n # j = row\\n\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n # Mx = (y_cg - y_i)F_znet - (z_cg - z_i)F_ynet + M_xnet\\n soln_mat[rX] = - ((_cg[1] - F[i].xyz[1]) * _netLoad.force[2]\\n - (_cg[2] - F[i].xyz[2]) * _netLoad.force[1]\\n + _netLoad.moment[0])\\n\\n # My = (z_cg - z_i)F_xnet - (x_cg - x_i)F_znet + M_ynet\\n soln_mat[rY] = -((_cg[2] - F[i].xyz[2]) * _netLoad.force[0]\\n - (_cg[0] - F[i].xyz[0]) * _netLoad.force[2]\\n + _netLoad.moment[1])\\n\\n # Mz = (x_cg - x_i)F_ynet - (y_cg - y_i)F_xnet + M_znet\\n soln_mat[rZ] = -((_cg[0] - F[i].xyz[0]) * _netLoad.force[1]\\n - (_cg[1] - F[i].xyz[1]) * _netLoad.force[0]\\n + _netLoad.moment[2])\\n\\n # Solve system of equations\\n matSol = np.linalg.lstsq(coef_mat, soln_mat)[0]\\n\\n # Add resulting fastener loads to fastener objects\\n for i, j in enumerate(cSet):\\n rX = j[0]\\n rY = j[1]\\n rZ = j[2]\\n\\n F[i].force[0] = matSol[rX]\\n F[i].force[1] = matSol[rY]\\n F[i].force[2] = matSol[rZ]\",\n \"def compute(self) -> Union[Tensor, Tuple[Tensor, Tensor]]:\\n preds_dataloader = _get_dataloader(\\n input_ids=dim_zero_cat(self.preds_input_ids),\\n attention_mask=dim_zero_cat(self.preds_attention_mask),\\n idf=self.idf,\\n batch_size=self.batch_size,\\n num_workers=self.num_threads,\\n )\\n target_dataloader = _get_dataloader(\\n input_ids=dim_zero_cat(self.target_input_ids),\\n attention_mask=dim_zero_cat(self.target_attention_mask),\\n idf=self.idf,\\n batch_size=self.batch_size,\\n num_workers=self.num_threads,\\n )\\n\\n info_lm_score = _infolm_compute(\\n self.model,\\n preds_dataloader,\\n target_dataloader,\\n self.temperature,\\n self.idf,\\n self.information_measure_cls,\\n self.special_tokens_map,\\n self.verbose,\\n )\\n\\n if self.return_sentence_level_score:\\n return info_lm_score.mean(), info_lm_score\\n\\n return info_lm_score.mean()\",\n \"def _compute_carry_and_output(self, x, h_tm1, c_tm1):\\n x_i, x_f, x_c, x_o = x\\n h_tm1_i, h_tm1_f, h_tm1_c, h_tm1_o = h_tm1\\n i = self.recurrent_activation(\\n x_i + K.dot(h_tm1_i, self.recurrent_kernel[:, :self.units]))\\n f = self.recurrent_activation(x_f + K.dot(\\n h_tm1_f, self.recurrent_kernel[:, self.units:self.units * 2]))\\n c = f * c_tm1 + i * self.activation(x_c + K.dot(\\n h_tm1_c, self.recurrent_kernel[:, self.units * 2:self.units * 3]))\\n o = self.recurrent_activation(\\n x_o + K.dot(h_tm1_o, self.recurrent_kernel[:, self.units * 3:]))\\n return c, o\",\n \"def __init__(self):\\n super(LinearAggregationLayer, self).__init__()\",\n \"def compute_IC(self, n_params=1):\\n self.IC = information_criterion(self, n_params=n_params)\",\n \"def rebuild_the_laplacians():\\n local_matrix = InteractomeInterface()\\n local_matrix.full_rebuild()\\n\\n annot_matrix = AnnotomeInterface()\\n annot_matrix.full_rebuild()\",\n \"def global_analysis(tomo, b_th, c=18):\\n\\n ## Thesholding and Volume analysis\\n if c == 6:\\n con_mat = [ [[0, 0, 0], [0, 1, 0], [0, 0, 0]],\\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]],\\n [[0, 0, 0], [0, 1, 0], [0, 0, 0]] ]\\n elif c == 18:\\n con_mat = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]]]\\n elif c == 26:\\n con_mat = [[[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]\\n else:\\n raise ValueError\\n tomo_lbl, num_lbls = sp.ndimage.label(tomo >= b_th, structure=np.ones(shape=[3, 3, 3]))\\n tomo_out = np.zeros(shape=tomo.shape, dtype=int)\\n lut = np.zeros(shape=num_lbls+1, dtype=int)\\n\\n ## COUNTING REGIONS METHODS\\n # import time\\n # hold_t = time.time()\\n # for lbl in range(1, num_lbls + 1):\\n # ids = tomo == lbl\\n # feat_sz = len(ids)\\n # tomo_out[ids] = feat_sz\\n # # print('[1]:', lbl, 'of', num_lbls)\\n # print time.time() - hold_t\\n\\n ## COUNTING PIXELS METHOD\\n ## Count loop\\n # cont, total = 0, np.prod(tomo.shape)\\n # import time\\n # hold_t = time.time()\\n for x in range(tomo.shape[0]):\\n for y in range(tomo.shape[1]):\\n for z in range(tomo.shape[2]):\\n id = tomo_lbl[x, y, z]\\n lut[id] += 1\\n # cont += 1\\n # print('[1]:', cont, 'of', total)\\n #\\n ## Write loop\\n # cont, total = 0, np.prod(tomo.shape)\\n\\n for x in range(tomo.shape[0]):\\n for y in range(tomo.shape[1]):\\n for z in range(tomo.shape[2]):\\n id = tomo_lbl[x, y, z]\\n if id > 0:\\n tomo_out[x, y, z] = lut[id]\\n # cont += 1\\n # print('[1]:', cont, 'of', total)\\n # print time.time() - hold_t\\n\\n return tomo_out\",\n \"def multiply(self, layer):\\n pass\",\n \"def scalarInfo(img, cnt):\\n\\tm = cntInfo(img, cnt)\\n\\td = {\\\"perimeter\\\":m[\\\"perimeter\\\"], \\\"oreientation\\\":m[\\\"orientation\\\"], \\\"solidity\\\":m[\\\"solidity\\\"],\\\"height\\\":m[\\\"height\\\"], \\\"extent\\\":m[\\\"extent\\\"], \\\"aspect ratio\\\":m[\\\"aspect ratio\\\"], \\\"area\\\":m[\\\"area\\\"], \\\"sum intensity\\\":m[\\\"sum intensity\\\"], \\\"width\\\":m[\\\"width\\\"], \\\"equivalent diameter\\\": m[\\\"equivalent diameter\\\"], \\\"mean intensity\\\": m[\\\"mean intensity\\\"]}\\n\\treturn d\",\n \"def dimensionality_reduction(dataset, algorithm, sampled_frac=0.05):\\n num_samples = int(len(dataset.index)*sampled_frac)\\n sample = dataset[:num_samples]\\n category_labels = sample[\\\"Rings\\\"]\\n sample = sample.drop(\\\"Rings\\\", axis =1)\\n if algorithm ==\\\"PCA\\\":\\n dim_reducer = PCA(n_components=3)\\n if algorithm == \\\"MDS\\\":\\n dim_reducer = MDS(n_components = 3)\\n if algorithm ==\\\"TSNE\\\":\\n dim_reducer = TSNE(n_components=3)\\n if algorithm == \\\"isomap\\\":\\n dim_reducer = Isomap(n_components=3)\\n \\n reduced_dataset = dim_reducer.fit_transform(sample)\\n\\n fig = plt.figure()\\n plt.clf()\\n ax = fig.add_subplot(111, projection='3d')\\n\\n plt.cla()\\n ax.scatter(reduced_dataset[:,0], reduced_dataset[:,1], reduced_dataset[:,2],c=category_labels.astype(str),cmap=plt.cm.spectral)\\n\\n ax.view_init(azim=30)\\n plt.show()\\n \\n # plt.scatter(reduced_dataset[:,0], reduced_dataset[:,1], c=category_labels.astype(str))\\n # plt.xlabel(\\\"z1\\\")\\n # plt.ylabel(\\\"z2\\\")\\n # plt.show()\",\n \"def _calculate_information_gain(self, cur_state, next_state):\\n\\n n = len(cur_state)\\n information_gain_per_action = np.zeros((n, self.action_dim))\\n\\n prob_cur = self.classifier.get_class1_prob(obs=cur_state)\\n prob_next = self.classifier.get_class1_prob(obs=next_state)\\n information_gain_true = (prob_next - prob_cur).reshape(-1, 1)\\n\\n next_state_null = np.copy(next_state)\\n next_state_null[:, -self.action_dim:] = self.classifier.missing_value\\n prob_next_null = self.classifier.get_class1_prob(next_state_null)\\n\\n for i in range(self.action_dim):\\n next_state_i = np.copy(next_state)\\n next_state_i[:, -self.action_dim:] = self.classifier.missing_value\\n next_state_i[:, -i - 1] = next_state[:, -i - 1]\\n\\n prob_next_i = self.classifier.get_class1_prob(obs=next_state_i)\\n information_gain_per_action[:, -i - 1] = prob_next_i - prob_next_null\\n\\n information_gain_sum = np.sum(information_gain_per_action, axis=1, keepdims=True)\\n ratio = information_gain_true / information_gain_sum\\n ratio[information_gain_sum == 0] = 0\\n information_gain_per_action = information_gain_per_action * ratio\\n return information_gain_per_action\",\n \"def specificity():\\n\\tatlas = 'power'\\n\\tproject='hcp'\\n\\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\\\"Strength of r's, i's PC & j's Q\\\"]\\n\\ttasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL',]\\n\\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\\n\\tdf = pd.DataFrame(columns = df_columns)\\n\\tfor task in tasks:\\n\\t\\tprint task\\n\\t\\t# subjects = np.array(hcp_subjects).copy()\\n\\t\\t# subjects = list(subjects)\\n\\t\\t# subjects = remove_missing_subjects(subjects,task,atlas)\\n\\t\\tsubjects = np.load('/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %('hcp',task,atlas))\\n\\t\\tstatic_results = graph_metrics(subjects,task,atlas,'fz')\\n\\t\\tsubject_pcs = static_results['subject_pcs']\\n\\t\\tsubject_wmds = static_results['subject_wmds']\\n\\t\\tsubject_mods = static_results['subject_mods']\\n\\t\\tsubject_wmds = static_results['subject_wmds']\\n\\t\\tmatrices = static_results['matrices']\\n\\t\\t#sum of weight changes for each node, by each node.\\n\\t\\thub_nodes = ['WCD']\\n\\t\\t# hub_nodes = ['PC']\\n\\t\\tdriver_nodes_list = ['Q+','Q-']\\n\\t\\t# driver_nodes_list = ['Q+']\\n\\t\\tmean_pc = np.nanmean(subject_pcs,axis=0)\\n\\t\\tmean_wmd = np.nanmean(subject_wmds,axis=0)\\n\\t\\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\\n\\t\\tfor i in range(subject_pcs.shape[1]):\\n\\t\\t\\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\\n\\t\\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\\n\\t\\tfor i in range(subject_wmds.shape[1]):\\n\\t\\t\\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\\n\\t\\tfor hub_node in hub_nodes:\\n\\t\\t\\tif hub_node == 'PC':\\n\\t\\t\\t\\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_pcs,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(project,task,atlas)))\\n\\t\\t\\t\\tconnector_nodes = np.where(mod_pc_corr>0.0)[0]\\n\\t\\t\\t\\tlocal_nodes = np.where(mod_pc_corr<0.0)[0]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(project,task,atlas)))\\n\\t\\t\\t\\tconnector_nodes = np.where(mod_wmd_corr>0.0)[0]\\n\\t\\t\\t\\tlocal_nodes = np.where(mod_wmd_corr<0.0)[0]\\n\\t\\t\\tedge_thresh_val = 50.0\\n\\t\\t\\tedge_thresh = np.percentile(np.nanmean(matrices,axis=0),edge_thresh_val)\\n\\t\\t\\tpc_edge_corr[:,np.nanmean(matrices,axis=0) 1: #case of multioutput prediction\\n m = np.shape(y)[0] #number of samples\\n n = np.shape(y)[1] #number of output elements\\n \\n #calculating gradients for each layer\\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\\n \\n if layer == len(self.architecture)-1: #identifies output layer and does output layer specific calculations\\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y= y)\\n da_LdZ_L = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\\n delta_L = np.multiply(dCda_L,da_LdZ_L)\\n self.all_data[f'dCda_{layer}'] = dCda_L\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\\n self.all_data[f'delta_{layer}'] = delta_L\\n else: #for other layers\\n da_LdZ_l = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \\n self.all_data[f'delta_{layer}'] = delta_l\\n \\n dCdW_l = np.outer(np.sum(self.all_data[f'A{layer-1}'],axis=0)*(1/m),self.all_data[f'delta_{layer}'])\\n dCdb_l = self.all_data[f'delta_{layer}']\\n\\n ##saving calculated data\\n self.all_data[f'dCdW{layer}'] = dCdW_l\\n self.all_data[f'dCdb{layer}'] = dCdb_l\\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l\\n \\n else: #calculations for single dataset(eg for SGD)\\n m = 1\\n n = len(y)\\n\\n ##calculating gradients for each layer\\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\\n \\n if layer == len(self.architecture)-1:\\n #dCda_L = (self.all_data[f'A{layer}'] - y)*(1/(m*n))*2\\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y=y)\\n da_LdZ_L = self.derivatives(self.all_data[f'Z{layer}'],activation)\\n delta_L = np.multiply(dCda_L,da_LdZ_L)\\n self.all_data[f'dCda_{layer}'] = dCda_L\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\\n self.all_data[f'delta_{layer}'] = delta_L\\n else:\\n da_LdZ_l = self.derivatives(self.all_data[f'Z{layer}'],activation)\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \\n self.all_data[f'delta_{layer}'] = delta_l\\n\\n dCdW_l = np.outer(self.all_data[f'A{layer-1}'],self.all_data[f'delta_{layer}'])\\n dCdb_l = self.all_data[f'delta_{layer}']\\n\\n #saving data\\n self.all_data[f'dCdW{layer}'] = dCdW_l\\n self.all_data[f'dCdb{layer}'] = dCdb_l\\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l\",\n \"def _reduce(self, x, y):\\n coef = self._update_parallel_coef_constraints(x)\\n self.coef_ = coef.T\",\n \"def mutual_information(pred, true):\\n \\n #for now , only for univariate forecasting. So reshapes entire batch of K timesteps into vector as if single feature\\n MI = mutual_info_regression(true.detach().numpy().flatten().reshape(-1,1), pred.detach().numpy().flatten())[0]\\n return torch.tensor(MI)\",\n \"def computeConeActivity(Analysis, ImageData, rec_field, cpd, _meta,\\n _brownian=True, glasses=False):\\n Rec_Field = (rec_field[540]['fft'] / rec_field['max']) \\n \\n ImageData['fitLaw'] = ImageData['powerlaw'](cpd[1:])\\n powerlaw = ImageData['fitLaw']\\n\\n if _brownian: \\n temp = np.arange(1, 80)\\n movement_filter = brownian_motion(cpd[1:], temp)\\n powerlaw *= movement_filter\\n\\n # compute the diffraction limited case seperately\\n diffract = {}\\n diff, _x = o.diffraction(_meta['samples'], \\n _meta['pupil_size'],\\n 16.6, \\n ref_index=1.4, \\n wavelength=550.0)\\n # now interpolate mtf into cpd's of analysis:\\n mtf = np.interp(cpd, _x, diff)\\n\\n # remove zeros to avoid errors in future computations:\\n ind = np.where(mtf != 0)[0]\\n diffract['cpd'] = cpd[ind]\\n diffract['mtf'] = mtf[ind]\\n\\n diffract['preCone'] = (powerlaw[ind] * \\n diffract['mtf'][ind])\\n diffract['retina'] = (diffract['preCone'] *\\n Rec_Field[ind])\\n\\n if glasses:\\n # if glasses on, compute effect after diffraction case\\n powerlaw *= gauss(cpd[1:], 10)\\n\\n for key in Analysis:\\n # find cone fft:\\n wv = Analysis[key]['wavelength']\\n Rec_Field = (rec_field[wv]['fft'] / rec_field['max'])\\n\\n # generate MTFs for each condition:\\n intensity = traceEye(\\n Analysis[key]['dist'], \\n Analysis[key]['off_axis'], \\n Analysis[key]['pupil_size'], \\n Analysis[key]['focus'],\\n Analysis[key]['wavelength'])\\n psf = o.genPSF(intensity, _meta['samples'])[1]\\n Analysis[key]['mtf'] = o.genMTF(psf)[ind]\\n\\n Analysis[key]['preCone'] = (powerlaw[ind] * \\n Analysis[key]['mtf'])\\n\\n Analysis[key]['retina'] = (Analysis[key]['preCone'] *\\n Rec_Field[ind])\\n\\n return Analysis, diffract\",\n \"def forward(self, image1, image2, intrinsic, posepred, insmap, initialdepth=None, iters=12):\\n image2_org = torch.clone(image2)\\n\\n image1 = 2 * image1 - 1.0\\n image2 = 2 * image2 - 1.0\\n\\n image1 = image1.contiguous()\\n image2 = image2.contiguous()\\n\\n hdim = self.hidden_dim\\n cdim = self.context_dim\\n\\n # run the feature network\\n fmap1, fmap2 = self.fnet([image1, image2])\\n\\n bz, _, featureh, featurew = fmap1.shape\\n device = fmap1.device\\n self.init_sampling_pts(bz, featureh, featurew, device)\\n \\n fmap1 = fmap1.float()\\n fmap2 = fmap2.float()\\n corr_fn = CorrBlock(fmap1, fmap2, intrinsic, posepred, insmap, nedges=self.nedges, maxinsnum=self.args.maxinsnum)\\n\\n # run the context network\\n cnet = self.cnet(image1)\\n net, inp = torch.split(cnet, [hdim, cdim], dim=1)\\n net = torch.tanh(net)\\n inp = torch.relu(inp)\\n\\n bz, _, h, w = image1.shape\\n if initialdepth is None:\\n logdepth = self.initialize_logdepth(image1)\\n else:\\n logdepth = F.interpolate(torch.log(torch.clamp_min(initialdepth, min=1)), [int(h / 8), int(w / 8)], mode='nearest')\\n\\n depth_predictions = []\\n logdepth_predictions = []\\n local_sample_pts2ds = []\\n delta_depths = []\\n outputs = dict()\\n for itr in range(iters):\\n corr, local_sample_pts2d = corr_fn(logdepth, sampled_rld=self.sampled_rld, pts2ddict=self.pts2ddict) # index correlation volume\\n\\n net, up_mask, delta_depth = self.update_block(net, inp, corr, logdepth)\\n\\n # F(t+1) = F(t) + \\\\Delta(t)\\n logdepth = logdepth + delta_depth\\n depth = torch.exp(logdepth)\\n\\n depth_up = self.upsample_flow(depth, up_mask)\\n\\n if itr == iters - 1:\\n flowpred, img1_recon, projMimg = self.depth2rgb(depth_up, image2_org, intrinsic, posepred, insmap)\\n outputs['flowpred'] = flowpred\\n outputs['img1_recon'] = img1_recon\\n # with torch.no_grad():\\n # outputs['orgflow'] = self.depth2flow(initialdepth, projMimg)\\n \\n depth_predictions.append(depth_up)\\n logdepth_predictions.append(F.interpolate(logdepth, [h, w], mode='bilinear', align_corners=False))\\n local_sample_pts2ds.append(local_sample_pts2d)\\n delta_depths.append(delta_depth)\\n\\n outputs['depth_predictions'] = depth_predictions\\n outputs['logdepth_predictions'] = logdepth_predictions\\n outputs['local_sample_pts2ds'] = local_sample_pts2ds\\n outputs['delta_depths'] = delta_depths\\n return outputs\",\n \"def calc_perc_reducts():\\n #Load RCP2.6 datq\\n cubes = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')\\n #Get the surface and high level SO2 emissions\\n surf_cube = cubes[3][:,0]\\n high_cube = cubes[1][:,0]\\n cubes = iris.cube.CubeList([surf_cube,high_cube])\\n\\n for i in range(0,len(cubes)):\\n #Add the year and month to the cube and extract for 2009 onwards\\n iris.coord_categorisation.add_year(cubes[i],'time',name='year')\\n iris.coord_categorisation.add_month(cubes[i],'time',name='month')\\n cubes[i] = cubes[i].extract(iris.Constraint(year = lambda y: y >=2009))\\n\\n #Make the year-on-year reduction rates\\n yoy_rates = []\\n for cube in cubes:\\n #Calculate the global mean timeseries\\n cube.coord('latitude').guess_bounds()\\n cube.coord('longitude').guess_bounds()\\n area_weights = iris.analysis.cartography.area_weights(cube)\\n cube_mean = cube.collapsed(['latitude','longitude'],iris.analysis.MEAN,weights=area_weights)\\n\\n cube_rates = np.ones((cube_mean.shape))\\n #Loop over the months and calculate the changes from the previous year\\n #Calculate the year on year proportional changes in the global mean\\n for i in range(12,cube_mean.shape[0]):\\n cube_rates[i] = cube_mean[i].data / cube_mean[(i-12)].data\\n\\n yoy_rates.append(cube_rates)\\n\\n return yoy_rates\",\n \"def empirical_cor(l):\\n\\n global fig_dphi\\n\\n # first clean los\\n maps_temp = np.matrix.copy(maps[:,:,l]) - np.matrix.copy(models[:,:,l])\\n\\n # no estimation on the ref image set to zero \\n if np.nansum(maps[:,:,l]) != 0:\\n\\n maxlos,minlos=np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],float(arguments[\\\"--perc_los\\\"])),np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],100-float(arguments[\\\"--perc_los\\\"]))\\n logger.debug('Set Max-Min LOS for empirical estimation: {0}-{1}'.format(maxlos,minlos))\\n kk = np.nonzero(np.logical_or(maps_temp==0.,np.logical_or((maps_temp>maxlos),(maps_tempmintopo,\\n np.logical_and(mask_flat>float(arguments[\\\"--threshold_mask\\\"]),\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(~np.isnan(rmsmap),\\n np.logical_and(~np.isnan(elev),\\n np.logical_and(rmsmap1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>ibeg_emp,\\n np.logical_and(pix_azjbeg_emp,\\n np.logical_and(pix_rg0.,\\n ))))))))\\n ))))))\\n\\n # extract coordinates for estimation\\n temp = np.array(index).T\\n x = temp[:,0]; y = temp[:,1]\\n # clean maps\\n los_clean = maps_temp[index].flatten()\\n topo_clean = elev[index].flatten()\\n rms_clean = rmsmap[index].flatten()\\n \\n logger.debug('Number of points for empirical estimation: {}'.format(len(los_clean)))\\n if len(los_clean) < 1:\\n logger.critical('No points left for empirical estimation. Exit!')\\n logger.critical('threshold RMS: {0}, threshold Mask: {1}, Min-Max LOS: {2}-{3}, Min-Max topo: {4}-{5}, lines: {6}-{7}, \\\\\\n cols: {8}- {9}'.format(float(arguments[\\\"--threshold_rms\\\"]),float(arguments[\\\"--threshold_mask\\\"]),minlos,maxlos,mintopo,maxtopo,ibeg_emp,iend_emp,jbeg_emp,jend_emp))\\n sys.exit()\\n\\n # print itemp, iend_emp\\n if flat>5 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\\n logger.warning('Image too short in comparison to master, set flat to 5')\\n temp_flat=5\\n else:\\n temp_flat=flat\\n\\n if ivar>0 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\\n logger.warning('Image too short in comparison to master, set ivar to 0')\\n ivar_temp=0\\n nfit_temp=0\\n else:\\n ivar_temp=ivar\\n nfit_temp=nfit\\n\\n # call ramp estim\\n los = as_strided(maps[:,:,l]).flatten()\\n samp = int(arguments[\\\"--emp_sampling\\\"])\\n\\n map_ramp, map_flata, map_topo, rmsi = estim_ramp(los,los_clean[::samp],topo_clean[::samp],x[::samp],\\\\\\n y[::samp],temp_flat,rms_clean[::samp],nfit_temp, ivar_temp, l, ax_dphi)\\n\\n if (lin_start is not None) and (lin_end is not None):\\n # try:\\n indexref = np.nonzero(np.logical_and(elevmintopo,\\n np.logical_and(mask_flat>float(arguments[\\\"--threshold_mask\\\"]),\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(~np.isnan(rmsmap),\\n np.logical_and(~np.isnan(elev),\\n np.logical_and(rmsmap1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>lin_start,\\n np.logical_and(pix_azcol_start,\\n np.logical_and(pix_rg0.,\\n ))))))))))))\\n ))\\n \\n if len(indexref[0]) == 0:\\n logger.warning('Ref zone is empty! Re-define --ref_zone argument. Exit!')\\n sys.exit()\\n\\n ## Set data minus temporal model to zero in the ref area\\n zone = as_strided(map_flata[:,:] - models[:,:,l])\\n los_ref2 = zone[indexref].flatten()\\n rms_ref = rmsmap[indexref].flatten()\\n amp_ref = 1./rms_ref\\n amp_ref = amp_ref/np.nanmax(amp_ref)\\n # weigth avera of the phase\\n cst = np.nansum(los_ref2*amp_ref) / np.nansum(amp_ref)\\n logger.info('Re-estimation of a constant within lines {0}-{1} and cols {2}-{3}'.format(lin_start,lin_end,col_start,col_end))\\n logger.info('Average phase within ref area: {0}:'.format(cst))\\n if np.isnan(cst):\\n cst = 0.\\n map_ramp, map_flata = map_ramp + cst, map_flata - cst\\n del zone\\n \\n else:\\n map_flata = np.copy(maps[:,:,l])\\n map_ramp, map_topo = np.zeros(np.shape(map_flata)), np.zeros(np.shape(map_flata))\\n rmsi = 1\\n\\n # set ramp to NaN to have ramp of the size of the images\\n kk = np.nonzero(np.isnan(map_flata))\\n ramp = as_strided(map_ramp)\\n ramp[kk] = float('NaN')\\n topo = as_strided(map_topo)\\n topo[kk] = float('NaN')\\n del ramp, topo\\n \\n return map_ramp, map_flata, map_topo, rmsi\",\n \"def calculate_information_criterion(R, u_t, R_test, u_t_test, inverse_transform, inverse_transform_test, algo, x_nodes):\\n model_list = generate_models(R, u_t, inverse_transform, algo) # iterates hyperparameters to generate models\\n evidence_list = calculate_bic(R_test, u_t_test, inverse_transform_test, model_list, x_nodes)\\n return evidence_list, model_list\",\n \"def calculate_all_metrcis(self):\\n self.calculate_gc_metrcis()\\n self.calculate_sam_metrics()\\n self.calculate_classification_metrics()\\n self.calculate_losses()\",\n \"def dataModel():\\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\\n\\n image_data = fits.getdata('6gev_image.fits')\\n filename = get_pkg_data_filename('6gev_image.fits')\\n hdu = fits.open(filename)[0]\\n wcs = WCS(hdu.header)\\n\\n #Given the results of the fit, calculate the model\\n modelData001 = np.zeros(srcmap001[0].shape)\\n modelData03 = np.zeros(srcmap03[0].shape)\\n\\n file = open('plotsData/fitResults001.pk1','rb')\\n fit001 = pickle.load(file)\\n file.close()\\n\\n file = open('plotsData/fitResults03.pk1','rb')\\n fit03 = pickle.load(file)\\n file.close()\\n\\n\\n for source in fit001:\\n the_index = srcmap001.index_of(source)\\n\\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\\n for source in fit03:\\n the_index = srcmap03.index_of(source)\\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\\n\\n fig = plt.figure(figsize=[12, 4.5])\\n\\n vmin = 0\\n vmax = 70.0\\n cbStep = 10.0\\n ax = fig.add_subplot(121, projection=wcs)\\n ax=plt.gca()\\n ax.tick_params(direction='in')\\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\\n ax.add_patch(c)\\n mappable=plt.imshow((image_data),cmap='inferno',origin='lower',norm=colors.PowerNorm(gamma=0.6),vmin=vmin, vmax=vmax, interpolation='gaussian')#\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('Data ($>6$ GeV)')\\n cb = plt.colorbar(mappable, label='Counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb.ax.tick_params(width=0)\\n\\n\\n ax2=fig.add_subplot(122, projection=wcs)\\n ax2 = plt.gca()\\n\\n sources = []\\n sources.append({\\n 'Name':'3FGL J1745.3-2903c',\\n 'RA':266.3434922,\\n 'DEC':-29.06274323,\\n 'color':'xkcd:bright light blue'})\\n\\n sources.append({\\n 'Name':'1FIG J1748.2-2816',\\n 'RA':267.1000722,\\n 'DEC':-28.27707114,\\n 'color':'xkcd:fire engine red'\\n })\\n\\n sources.append({\\n 'Name':'1FIG J1746.4-2843',\\n 'RA':266.5942898,\\n 'DEC':-28.86244442,\\n 'color':'xkcd:fluorescent green'\\n })\\n\\n sources.append({\\n 'Name':'Galactic Center',\\n 'RA':266.417,\\n 'DEC':-29.0079,\\n 'color':'black'\\n })\\n\\n #Add source names:\\n for source in sources:\\n l, b = ra_dec_to_l_b(source['RA'], source['DEC'])\\n ax2.scatter(l, b, color=source['color'],marker='x',s=45.0, transform=ax2.get_transform('galactic'), label=source['Name'])\\n\\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\\n ax2.add_patch(c2)\\n mappable2 = plt.imshow((np.sum(modelData03,axis=0)), cmap='inferno',norm=colors.PowerNorm(gamma=0.6),origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('Model ($>6$ GeV)')\\n cb2 = plt.colorbar(mappable2, label='Counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb2.ax.tick_params(width=0)\\n leg = plt.legend(loc=1,frameon=True)\\n leg.get_frame().set_alpha(0.5)\\n leg.get_frame().set_edgecolor('white')\\n text1 = leg.get_texts()\\n for text in text1:\\n text.set_color('black')\\n\\n fig.tight_layout()\\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\\n plt.show()\\n #plt.savefig('plots/dataModelComparison.pdf',bbox_inches='tight')\",\n \"def summary(self):\\n for i,layer in enumerate(self.chain):\\n x = Input([2])\\n y = layer.forward(x)\\n Model(x,y,name=f'layer_{i}_summary').summary()\",\n \"def calculate_correlation(data):\\n pass\",\n \"def constant_2015():\\n\\n #Load the CMIP6 historical\\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\\n #Get low and high level emissions just in the last year (2014)\\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\\n final_cubes = iris.cube.CubeList()\\n for cube in cubes:\\n final_cube = cube[-12:]\\n final_cubes.append(final_cube)\\n \\n #Set the year-on-year proportional reductions to be nothing\\n yoy_rates = calc_perc_reducts()\\n yoy_rates = np.array(yoy_rates)\\n yoy_rates = np.ones_like(yoy_rates)\\n\\n #Create coordinates for new nc file between 2014 and 2100\\n lat_coord = cubes[0].coord('latitude')\\n lon_coord = cubes[0].coord('longitude')\\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\\n\\n #Create the cube date\\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n #Set first year equal to 2014 in CMIP6 historical\\n cube_data_surf[:12,...] = final_cubes[0].data\\n cube_data_high[:12,...] = final_cubes[1].data\\n #Apply equal emissions in all other years too\\n for i in range(12,cube_data_surf.shape[0]):\\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\\n #Make the output cubes\\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\\n\\n fut_cube_high.var_name = 'field569_1'\\n fut_cube_high.units='kg/m2/s'\\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\\n fut_cube_surf.var_name = 'field569'\\n fut_cube_surf.units='kg/m2/s'\\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\\n\\n #Load the DMS cube from standard RCP2.6\\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\\n\\n dms_cube.var_name = 'field570'\\n dms_cube.attributes.pop('name')\\n dms_cube.coord('time').var_name = 'time'\\n dms_cube.coord('time').long_name = 'time'\\n\\n fut_cube_high = fut_cube_high[:-2]\\n fut_cube_surf = fut_cube_surf[:-2]\\n\\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\\n\\n #Save the final cubes as netcdf (cutting them to be the same length)\\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n os.system('ncatted -O -a calendar,time,m,c,\\\"360_day\\\" '+data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n\\n return\",\n \"def calculate_correlations(model_metric = \\\"MSE\\\", correlation_type = \\\"Pearsons\\\", save = True):\\n \\n if model_metric == \\\"MSE\\\":\\n augmented_results = 'augmented_mse.csv'\\n else:\\n augmented_results = 'augmented_f1_score.csv'\\n \\n main_path = Path(os.path.dirname(__file__)).parent\\n metadata_path = r\\\"visualize_results\\\"\\n metadata = pd.read_csv(os.path.join(main_path, metadata_path, augmented_results))\\n \\n metadata['DateTime'] = pd.to_datetime(metadata['DateTime'], dayfirst = True)\\n \\n cleanup_nums = {\\\"Day_Night\\\": {\\\"day\\\": 0, \\\"night\\\": 1}}\\n metadata = metadata.replace(cleanup_nums)\\n \\n tested_columns = [model_metric,\\\"Temperature\\\", \\\"Humidity\\\", \\\"Wind Speed\\\", \\\"Wind Direction\\\", \\\"Precipitation\\\",\\\"Activity\\\", \\\"Day_Night\\\", \\\"Hour\\\"] \\n \\n all_correlations = []\\n all_p_values = []\\n for model in metadata[\\\"model\\\"].unique():\\n \\n metadata_smaller = metadata[(metadata[\\\"model\\\"]== model)].copy()\\n metadata_smaller = metadata_smaller[tested_columns]\\n metadata_smaller = metadata_smaller.reset_index(drop=True)\\n \\n print(f\\\"For Model: {model}\\\")\\n corr_curr_model = []\\n p_value_curr_model =[]\\n for column in metadata_smaller.columns:\\n \\n if correlation_type == \\\"Pearsons\\\":\\n cor,p = stats.pearsonr(metadata_smaller[column], metadata_smaller[model_metric])\\n else:\\n cor,p = distcorr(metadata_smaller[column], metadata_smaller[model_metric],nruns = 5000)\\n \\n corr_curr_model.append(cor)\\n p_value_curr_model.append(p)\\n \\n print(f\\\"between {model_metric} and {column} = R: {np.abs(cor)}, p-val: {p}\\\")\\n \\n corr_curr_model.insert(0,model)\\n corr_curr_model.insert(0,model_metric)\\n corr_curr_model.insert(0,correlation_type)\\n \\n p_value_curr_model.insert(0,model)\\n p_value_curr_model.insert(0,model_metric)\\n p_value_curr_model.insert(0,correlation_type)\\n \\n print(\\\"---------------\\\")\\n all_correlations.append(corr_curr_model)\\n all_p_values.append(p_value_curr_model)\\n \\n all_correlations_df = pd.DataFrame(all_correlations,\\n columns = [\\\"Correlation\\\", \\\"Metric\\\", \\\"Model\\\"] + tested_columns)\\n \\n all_p_values_df = pd.DataFrame(all_p_values,\\n columns = [\\\"Correlation\\\", \\\"Metric\\\", \\\"Model\\\"] + tested_columns)\\n \\n if save:\\n all_correlations_df.to_csv(os.path.join(\\\"analysis_results\\\", f\\\"correlation_R_{correlation_type}_{model_metric}.csv\\\"), index=False)\\n all_p_values_df.to_csv(os.path.join(\\\"analysis_results\\\", f\\\"correlation_Pvalue_{correlation_type}_{model_metric}.csv\\\"), index=False)\\n \\n return all_correlations_df\",\n \"def filter_and_correct_expression_and_image_features(tissue, model, aggregation, patch_size, M, k, pc_correction=False, tf_correction=False):\\n\\n\\n\\n\\n # Filter expression\\n Y, X, dIDs, tIDs, tfs, ths, t_idx = extract_final_layer_data(tissue, model, aggregation, patch_size)\\n filt_X, filt_tIDs, final_exp_idx = filter_expression(X, tIDs, M, k)\\n\\n\\n\\n if pc_correction:\\n print ('Correcting with {} expression PCs'.format(pc_correction))\\n pca = PCA(n_components=pc_correction)\\n\\n\\n pca_predictors = pca.fit_transform(filt_X)\\n\\n # Correct Y\\n lr = LinearRegression()\\n lr.fit(pca_predictors, Y)\\n predicted_Y = lr.predict(pca_predictors)\\n corrected_Y = Y - predicted_Y\\n\\n # Correct X\\n projected_filt_X = np.dot(pca_predictors,pca.components_)\\n corrected_filt_X = filt_X - projected_filt_X\\n\\n # Set as return variables\\n final_X = corrected_filt_X\\n final_Y = corrected_Y\\n\\n elif tf_correction:\\n print('Correcting with all technical factors')\\n tf_Y = Y[t_idx,:]\\n tf_filt_X = filt_X[t_idx,:]\\n\\n tfs[list(ths).index('SMTSISCH')] = np.log2(tfs[list(ths).index('SMTSISCH')] + 1)\\n tf_predictors = tfs\\n\\n #Correct Y\\n lr_Y = LinearRegression()\\n lr_Y.fit(tf_predictors, tf_Y)\\n tf_Y_predicted = lr_Y.predict(tf_predictors)\\n corrected_tf_Y = tf_Y - tf_Y_predicted\\n\\n #Correct X\\n lr_X = LinearRegression()\\n lr_X.fit(tf_predictors, tf_filt_X)\\n tf_filt_X_predicted = lr_X.predict(tf_predictors)\\n corrected_tf_filt_X = tf_filt_X - tf_filt_X_predicted\\n\\n # Set as return variables\\n final_X = corrected_tf_filt_X\\n final_Y = corrected_tf_Y\\n else:\\n # Set unmodified values as return variables\\n final_X = filt_X\\n final_Y = Y\\n\\n return final_Y, final_X, dIDs, filt_tIDs, tfs, ths, t_idx\",\n \"def pan_corr(file):\\n\\n # # infile = 'd:\\\\\\\\Projekti\\\\\\\\Satelit\\\\\\\\CO\\\\\\\\Razpis\\\\\\\\Flat field images_new2020\\\\\\\\flatfield\\\\\\\\NHDBflat_1D'\\n # # infile = 'd:\\\\Projekti\\\\Satelit\\\\CO\\\\Razpis\\\\_POSNETKI\\\\Jure_naloga_banje_raw_pyt\\\\\\\\NHDRGoreMorje_3D'\\n #\\n # # in_path = 'd:\\\\Projekti\\\\Satelit\\\\CO\\\\Razpis\\\\Flat field images_new2020\\\\\\\\20201028 Vignetting\\\\\\\\flatfield\\\\\\\\'\\n # # in_pan_ref_file = 'NHDPflat_3D_py.tif'\\n # in_path = 'd:\\\\Projekti\\\\Satelit\\\\CO\\\\Razpis\\\\_POSNETKI\\\\Peking_PAN\\\\\\\\'\\n # in_pan_ref_file = 'NHDPfoc_swp6_1D_py.tif'\\n # in_ref = in_path + in_pan_ref_file\\n #\\n # inreffil = gdal.Open(in_ref)\\n # image_ref = inreffil.ReadAsArray()\\n # # size_ref = image_ref.shape\\n # # pix_count = size_ref[0]*size_ref[1]\\n #\\n # image_ref = image_ref[800:930, 1420:1640]\\n # size_ref = image_ref.shape\\n # pix_count = size_ref[0] * size_ref[1]\\n #\\n # g1 = 0.\\n # g2 = 0.\\n # r1 = 0.\\n # b1 = 0.\\n #\\n # for i in range(size_ref[0]):\\n # for j in range(size_ref[1]):\\n # if (i % 2) == 0 and (j % 2) == 0: g1 = g1 + image_ref[i, j]\\n # if (i % 2) == 1 and (j % 2) == 1: g2 = g2 + image_ref[i, j]\\n # if (i % 2) == 0 and (j % 2) == 1: r1 = r1 + image_ref[i, j]\\n # if (i % 2) == 1 and (j % 2) == 0: b1 = b1 + image_ref[i, j]\\n #\\n # g1_avg = g1 / pix_count * 4\\n # g2_avg = g2 / pix_count * 4\\n # r1_avg = r1 / pix_count * 4\\n # b1_avg = b1 / pix_count * 4\\n #\\n # raz_g1 = 1\\n # raz_g2 = g1_avg/g2_avg\\n # raz_r1 = g1_avg/r1_avg\\n # raz_b1 = g1_avg/b1_avg\\n #\\n # avg = (g1+g2+r1+b1)/pix_count\\n #\\n # print(g1_avg, g2_avg, r1_avg, b1_avg, avg)\\n\\n raz_g1 = 1\\n raz_g2 = 1.0245196396115988\\n raz_r1 = 1.0131841989689434\\n raz_b1 = 1.0517113199247086\\n\\n print('razmerje:', raz_g1, raz_g2, raz_r1, raz_b1)\\n\\n # in_path = 'd:\\\\Projekti\\\\Satelit\\\\CO\\\\Razpis\\\\_POSNETKI\\\\Peking_PAN\\\\\\\\'\\n # in_pan_ref_file = 'NHDPfoc_swp6_4D_py.tif'\\n # in_path = 'd:\\\\Projekti\\\\Satelit\\\\CO\\\\Razpis\\\\Flat field images_new2020\\\\\\\\20201028 Vignetting\\\\\\\\flatfield\\\\\\\\'\\n # in_pan_ref_file = 'NHDPflat_3D_py.tif'\\n\\n # in_path = 'd:\\\\Projekti\\\\Satelit\\\\CO\\\\Razpis\\\\_POSNETKI\\\\Slo_PAN\\\\_26_30\\\\\\\\'\\n # in_pan_ref_file = [filename for filename in os.listdir(in_path) if filename.lower().startswith(\\\"nhd\\\") and filename.lower().endswith(\\\"tif\\\")]\\n\\n \\n\\n \\n\\n # print('image', i)\\n in_ref=file\\n inreffil = gdal.Open(in_ref)\\n image_ref = inreffil.ReadAsArray()\\n size_ref = image_ref.shape\\n # pix_count = size_ref[0] * size_ref[1]\\n # pix_count = np.count_nonzero(image_ref)\\n # pix_count = 3664*650\\n\\n # g1 = 0.\\n # g2 = 0.\\n # r1 = 0.\\n # b1 = 0.\\n #\\n # for i in range(size_ref[0]):\\n # for j in range(size_ref[1]):\\n # if (i % 2) == 0 and (j % 2) == 0: g1 = g1 + image_ref[i, j]\\n # if (i % 2) == 1 and (j % 2) == 1: g2 = g2 + image_ref[i, j]\\n # if (i % 2) == 0 and (j % 2) == 1: r1 = r1 + image_ref[i, j]\\n # if (i % 2) == 1 and (j % 2) == 0: b1 = b1 + image_ref[i, j]\\n #\\n # g1_avg = g1 / pix_count * 4\\n # g2_avg = g2 / pix_count * 4\\n # r1_avg = r1 / pix_count * 4\\n # b1_avg = b1 / pix_count * 4\\n #\\n # avg = (g1 + g2 + r1 + b1) / pix_count\\n #\\n # print(g1_avg, g2_avg, r1_avg, b1_avg, avg)\\n\\n # popravek\\n im_p_pop = np.zeros((size_ref[0], size_ref[1]), np.uint16)\\n\\n\\n for i in range(size_ref[0]):\\n for j in range(size_ref[1]):\\n if (i % 2) == 0 and (j % 2) == 0 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_g1\\n if (i % 2) == 1 and (j % 2) == 1 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_g2\\n if (i % 2) == 0 and (j % 2) == 1 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_r1\\n if (i % 2) == 1 and (j % 2) == 0 and image_ref[i, j] != 0: im_p_pop[i, j] = image_ref[i, j] * raz_b1\\n \\n _,_,_,_,P=return_flatfield_set_path(2)\\n P_flat=gdal_array.LoadFile(P)\\n \\n # im_p_pop=simple_flatfield_corr(P_flat, im_p_pop, 2, 1) \\n \\n # outout\\n \\n im_p_pop=BLUE_simple_flatfield_corr(P_flat, im_p_pop)\\n \\n out=os.path.abspath(file)+\\\"/corr/\\\"+os.path.basename(file)[:-4] + \\\"_pop_flat_corr.tif\\\"\\n\\n \\n # out = in_ref[:-4] + \\\"_pop_flat_corr.tif\\\"\\n\\n driver = gdal.GetDriverByName('GTiff')\\n\\n # outRaster = driver.Create(out, size[1], size[0], 3, gdal.GDT_UInt16)\\n outRaster = driver.Create(out, size_ref[1], size_ref[0], 1, gdal.GDT_UInt16)\\n\\n outband = outRaster.GetRasterBand(1)\\n outband.WriteArray(im_p_pop)\\n outband.FlushCache()\",\n \"def compute(self,input):\\n\\n for layer in self.layers:\\n input = layer.compute(input)\\n return input\",\n \"def update_variables(self):\\n self.dl21 = self.l21-self.l11; self.dl22 = self.l22-self.l12; self.dl23 = self.l23-self.l13;\\n self.kappa1, self.phi1, self.seg_len1 = self.configuration_space(self.l11, self.l12, self.l13, self.d, self.n)\\n self.kappa2, self.phi2, self.seg_len2 = self.configuration_space(self.dl21, self.dl22, self.dl23, self.d, self.n)\\n # aquire transformation matrices and tips for segment 1 and 2\\n self.T01_bishop = self.transformation_matrix_bishop(self.kappa1, self.phi1, self.seg_len1)\\n self.T12_bishop = self.transformation_matrix_bishop(self.kappa2, self.phi2, self.seg_len2)\\n self.T02_bishop = np.matmul(self.T01_bishop, self.T12_bishop)\\n self.T01_frenet = self.transformation_matrix_frenet(self.kappa1, self.phi1, self.seg_len1)\\n self.T12_frenet = self.transformation_matrix_frenet(self.kappa2, self.phi2, self.seg_len2)\\n self.T02_frenet = np.matmul(self.T01_frenet, self.T12_frenet)\\n self.tip_vec1 = np.matmul(self.T01_bishop, self.base)[0:3]\\n self.tip_vec2 = np.matmul(self.T02_bishop, self.base)[0:3]\\n # Frenet frames\\n self.normal_vec_frenet1 = self.T01_frenet[0:3, 0]\\n self.binormal_vec_frenet1 = self.T01_frenet[0:3, 1]\\n self.tangent_vec_frenet1 = self.T01_frenet[0:3, 2]\\n self.normal_vec_frenet2 = self.T02_frenet[0:3, 0]\\n self.binormal_vec_frenet2 = self.T02_frenet[0:3, 1]\\n self.tangent_vec_frenet2 = self.T02_frenet[0:3, 2]\\n # Bishop frames\\n self.normal_vec_bishop1 = self.T01_bishop[0:3, 0]\\n self.binormal_vec_bishop1 = self.T01_bishop[0:3, 1]\\n self.tangent_vec_bishop1 = self.T01_bishop[0:3, 2]\\n self.normal_vec_bishop2 = self.T02_bishop[0:3, 0]\\n self.binormal_vec_bishop2 = self.T02_bishop[0:3, 1]\\n self.tangent_vec_bishop2 = self.T02_bishop[0:3, 2]\",\n \"def image_forward(self, general_x, general_y, general_z):\\n disti_p = F.pairwise_distance(general_y, general_z, 2)\\n disti_n1 = F.pairwise_distance(general_y, general_x, 2)\\n disti_n2 = F.pairwise_distance(general_z, general_x, 2)\\n target = torch.FloatTensor(disti_p.size()).fill_(1)\\n loss_sim_i1 = self.loss_sim_i(disti_p, disti_n1, target)\\n loss_sim_i2 = self.loss_sim_i(disti_p, disti_n2, target)\\n loss_sim_i = (loss_sim_i1 + loss_sim_i2) / 2.0\\n return loss_sim_i\",\n \"def _calculate_information_gain(self, cur_state, next_state, next_label):\\n n = len(cur_state)\\n information_gain_per_action = np.zeros((n, self.action_dim))\\n prob_prev = self.classifier.get_class1_prob(obs=cur_state)\\n\\n for i in range(self.action_dim):\\n obs_i = np.copy(next_state)\\n obs_i[:, -self.action_dim:] = cur_state[:, -self.action_dim:]\\n obs_i[:, - i - 1] = next_state[:, -i - 1]\\n\\n prob_i = self.classifier.get_class1_prob(obs=obs_i)\\n class_1_gain = (prob_i - prob_prev) * next_label[:, 0]\\n class_0_gain = (prob_i - prob_prev) * (1 - next_label)[:, 0]\\n\\n if self.positive_only:\\n class_1_gain[class_1_gain < 0] = 0\\n class_0_gain[class_0_gain < 0] = 0\\n else:\\n class_0_gain = - class_0_gain\\n\\n information_gain_per_action[:, - i - 1] = (class_1_gain + class_0_gain)\\n\\n return information_gain_per_action\",\n \"def extract(self,image_path):#image_path\\r\\n\\r\\n img = caffe.io.load_image(image_path)\\r\\n \\r\\n #image1=cv2.imread(caffe_root + 'examples/images/cat.jpg') \\r\\n #img=cv2.cvtColor(image1,cv2.COLOR_BGR2RGB) \\r\\n #img=img/255. \\r\\n \\r\\n\\r\\n transformed_image = self.transformer.preprocess('data', img)\\r\\n self.net.blobs['data'].data[...] = transformed_image\\r\\n ft = self.net.forward()\\r\\n ft = np.squeeze(ft['pool5/7x7_s1'])\\r\\n ft = ft / LA.norm(ft)\\r\\n return ft\",\n \"def run(self):\\n #self.source_fixed = center_of_mass(self.source_mesh.vs)\\n #self.destination_fixed = center_of_mass(self.destination_mesh.vs)\\n\\n source_high_curvature = get_mesh_of_high_curvature(self.source_mesh)\\n destination_high_curvature = get_mesh_of_high_curvature(self.destination_mesh)\\n\\n self.matrix, error = icp(source_high_curvature.vs, \\n destination_high_curvature.vs, \\n self.source_fixed, \\n self.destination_fixed,\\n 300,\\n verbose = self.verbose)\\n\\n self.inverse = np.linalg.inv(self.matrix)\\n self.global_confidence = 1 - error\\n print self.global_confidence\",\n \"def computeIntercepts():\\n pass\",\n \"def get_cost_updates(self, contraction_level, learning_rate):\\r\\n\\r\\n y = self.get_hidden_values(self.x)\\r\\n z = self.get_reconstructed_input(y)\\r\\n J = self.get_jacobian(y, self.W)\\r\\n # note : we sum over the size of a datapoint; if we are using\\r\\n # minibatches, L will be a vector, with one entry per\\r\\n # example in minibatch\\r\\n self.L_rec = - T.sum(self.x * T.log(z) +\\r\\n (1 - self.x) * T.log(1 - z),\\r\\n axis=1)\\r\\n\\r\\n # Compute the jacobian and average over the number of samples/minibatch\\r\\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\\r\\n\\r\\n # note : L is now a vector, where each element is the\\r\\n # cross-entropy cost of the reconstruction of the\\r\\n # corresponding example of the minibatch. We need to\\r\\n # compute the average of all these to get the cost of\\r\\n # the minibatch\\r\\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\\r\\n\\r\\n # compute the gradients of the cost of the `cA` with respect\\r\\n # to its parameters\\r\\n gparams = T.grad(cost, self.params)\\r\\n # generate the list of updates\\r\\n updates = []\\r\\n for param, gparam in zip(self.params, gparams):\\r\\n updates.append((param, param - learning_rate * gparam))\\r\\n\\r\\n return (cost, updates)\",\n \"def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\\n shape = tuple([None]+list(input_shape[1:]))\\n print(shape)\\n l_in = lasagne.layers.InputLayer(shape=shape)\\n\\n print(\\\"Input shape: \\\",lasagne.layers.get_output_shape(l_in))\\n\\n # print(shaped_units)\\n # shaped_units = shaped_units[0]\\n shaped_units = 2800\\n\\n # print(shape)\\n\\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\\n l_in, \\n num_filters=8,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n print(\\\"Conv 2D shape: \\\",lasagne.layers.get_output_shape(l_conv2D_1))\\n\\n l_reshape_1 = lasagne.layers.ReshapeLayer(\\n l_conv2D_1,\\n shape=(([0], -1))\\n )\\n\\n print(\\\"Reshape 1 shape: \\\", lasagne.layers.get_output_shape(l_reshape_1))\\n\\n l_hidden_1 = lasagne.layers.DenseLayer(\\n l_reshape_1,\\n num_units= num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 1 shape: \\\", lasagne.layers.get_output_shape(l_hidden_1))\\n\\n l_code_layer = lasagne.layers.DenseLayer(\\n l_hidden_1,\\n num_units=num_code_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Code layer shape: \\\",lasagne.layers.get_output_shape(l_code_layer))\\n\\n l_hidden_2 = lasagne.layers.DenseLayer(\\n l_code_layer,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 2 shape: \\\",lasagne.layers.get_output_shape(l_hidden_2))\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_hidden_2,\\n num_units=shaped_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 3 shape: \\\",lasagne.layers.get_output_shape(l_hidden_3))\\n\\n l_reshape_2 = lasagne.layers.ReshapeLayer(\\n l_hidden_3,\\n shape=(([0],8,7,50))\\n )\\n\\n print(\\\"Reshape 2 shape: \\\",lasagne.layers.get_output_shape(l_reshape_2))\\n\\n l_out = lasagne.layers.Conv2DLayer(\\n l_reshape_2, \\n num_filters=1,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n # print(\\\"Deconv shape: \\\",lasagne.layers.get_output_shape(l_deconv2D_1))\\n\\n print(\\\"Output shape: \\\",lasagne.layers.get_output_shape(l_out))\\n\\n return l_out\",\n \"def loss(self, z1, z2_con_z1, z3, z1_rec, z2_con_z1_rec, z3_rec):\\n pass\",\n \"def get_cost_updates(self, contraction_level, learning_rate):\\n self.n_batchsize = 20\\n y = self.get_hidden_values(self.x)\\n z = self.get_reconstructed_input(y)\\n J = self.get_jacobian(y, self.W)\\n # note : we sum over the size of a datapoint; if we are using\\n # minibatches, L will be a vector, with one entry per\\n # example in minibatch\\n self.L_rec = - T.sum(self.x * T.log(z) +\\n (1 - self.x) * T.log(1 - z),\\n axis=1)\\n\\n # Compute the jacobian and average over the number of samples/minibatch\\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\\n\\n # note : L is now a vector, where each element is the\\n # cross-entropy cost of the reconstruction of the\\n # corresponding example of the minibatch. We need to\\n # compute the average of all these to get the cost of\\n # the minibatch\\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\\n\\n # compute the gradients of the cost of the `cA` with respect\\n # to its parameters\\n gparams = T.grad(cost, self.params)\\n # generate the list of updates\\n updates = []\\n for param, gparam in zip(self.params, gparams):\\n updates.append((param, param - learning_rate * gparam))\\n\\n return (cost, updates)\",\n \"def compute_metrics(mat,language='English',method ='dimensional',output='data_frame'):\\n language = language.lower()\\n method = method.lower()\\n if language == 'english':\\n if method == 'dimensional':\\n if output == 'data_frame':\\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \\n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \\n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\\n return(mat)\\n elif output == 'array':\\n out_dict = {}\\n out_dict['PosVal'] = mat[:,:,0]\\n out_dict['NegVal'] = mat[:,:,1]\\n out_dict['Arousal'] = mat[:,:,2]\\n out_dict['Dominance'] = mat[:,:,3]\\n out_dict['PosCount'] = mat[:,:,4]\\n out_dict['DetectCount'] = mat[:,:,5]\\n out_dict['TokenCount'] = mat[:,:,6]\\n out_dict['ValSq'] = mat[:,:,7]\\n\\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\\n # Mean Values:\\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DetectCount'])\\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\\n # Percentages:\\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\")\\n elif method == 'discrete':\\n if output == 'data_frame':\\n mat['function_Percent'] = mat.function / mat.TokenCount\\n mat['pronoun_Percent'] = mat.pronoun / mat.TokenCount\\n mat['ppron_Percent'] = mat.ppron / mat.TokenCount\\n mat['i_Percent'] = mat.i / mat.TokenCount\\n mat['we_Percent'] = mat.we / mat.TokenCount\\n mat['you_Percent'] = mat.you / mat.TokenCount\\n mat['shehe_Percent'] = mat.shehe / mat.TokenCount\\n mat['they_Percent'] = mat.they / mat.TokenCount\\n mat['ipron_Percent'] = mat.ipron / mat.TokenCount\\n mat['article_Percent'] = mat.article / mat.TokenCount\\n mat['prep_Percent'] = mat.prep / mat.TokenCount\\n mat['auxverb_Percent'] = mat.auxverb / mat.TokenCount\\n mat['adverb_Percent'] = mat.adverb / mat.TokenCount\\n mat['conj_Percent'] = mat.conj / mat.TokenCount\\n mat['negate_Percent'] = mat.negate / mat.TokenCount\\n mat['verb_Percent'] = mat.verb / mat.TokenCount\\n mat['adj_Percent'] = mat.adj / mat.TokenCount\\n mat['compare_Percent'] = mat.compare / mat.TokenCount\\n mat['interrog_Percent'] = mat.interrog / mat.TokenCount\\n mat['number_Percent'] = mat.number / mat.TokenCount\\n mat['quant_Percent'] = mat.quant / mat.TokenCount\\n mat['affect_Percent'] = mat.affect / mat.TokenCount\\n mat['posemo_Percent'] = mat.posemo / mat.TokenCount\\n mat['negemo_Percent'] = mat.negemo / mat.TokenCount\\n mat['anx_Percent'] = mat.anx / mat.TokenCount\\n mat['anger_Percent'] = mat.anger / mat.TokenCount\\n mat['sad_Percent'] = mat.sad / mat.TokenCount\\n mat['social_Percent'] = mat.social / mat.TokenCount\\n mat['family_Percent'] = mat.family / mat.TokenCount\\n mat['friend_Percent'] = mat.friend / mat.TokenCount\\n mat['female_Percent'] = mat.female / mat.TokenCount\\n mat['male_Percent'] = mat.male / mat.TokenCount\\n mat['cogproc_Percent'] = mat.cogproc / mat.TokenCount\\n mat['insight_Percent'] = mat.insight / mat.TokenCount\\n mat['cause_Percent'] = mat.cause / mat.TokenCount\\n mat['discrep_Percent'] = mat.discrep / mat.TokenCount\\n mat['tentat_Percent'] = mat.tentat / mat.TokenCount\\n mat['certain_Percent'] = mat.certain / mat.TokenCount\\n mat['differ_Percent'] = mat.differ / mat.TokenCount\\n mat['percept_Percent'] = mat.percept / mat.TokenCount\\n mat['see_Percent'] = mat.see / mat.TokenCount\\n mat['hear_Percent'] = mat.hear / mat.TokenCount\\n mat['feel_Percent'] = mat.feel / mat.TokenCount\\n mat['bio_Percent'] = mat.bio / mat.TokenCount\\n mat['body_Percent'] = mat.body / mat.TokenCount\\n mat['health_Percent'] = mat.health / mat.TokenCount\\n mat['sexual_Percent'] = mat.sexual / mat.TokenCount\\n mat['ingest_Percent'] = mat.ingest / mat.TokenCount\\n mat['drives_Percent'] = mat.drives / mat.TokenCount\\n mat['affiliation_Percent'] = mat.affiliation / mat.TokenCount\\n mat['achieve_Percent'] = mat.achieve / mat.TokenCount\\n mat['power_Percent'] = mat.power / mat.TokenCount\\n mat['reward_Percent'] = mat.reward / mat.TokenCount\\n mat['risk_Percent'] = mat.risk / mat.TokenCount\\n mat['focuspast_Percent'] = mat.focuspast / mat.TokenCount\\n mat['focuspresent_Percent'] = mat.focuspresent / mat.TokenCount\\n mat['focusfuture_Percent'] = mat.focusfuture / mat.TokenCount\\n mat['relativ_Percent'] = mat.relativ / mat.TokenCount\\n mat['motion_Percent'] = mat.motion / mat.TokenCount\\n mat['space_Percent'] = mat.space / mat.TokenCount\\n mat['time_Percent'] = mat.time / mat.TokenCount\\n mat['work_Percent'] = mat.work / mat.TokenCount\\n mat['leisure_Percent'] = mat.leisure / mat.TokenCount\\n mat['home_Percent'] = mat.home / mat.TokenCount\\n mat['money_Percent'] = mat.money / mat.TokenCount\\n mat['relig_Percent'] = mat.relig / mat.TokenCount\\n mat['death_Percent'] = mat.death / mat.TokenCount\\n mat['informal_Percent'] = mat.informal / mat.TokenCount\\n mat['swear_Percent'] = mat.swear / mat.TokenCount\\n mat['netspeak_Percent'] = mat.netspeak / mat.TokenCount\\n mat['assent_Percent'] = mat.assent / mat.TokenCount\\n mat['nonflu_Percent'] = mat.nonflu / mat.TokenCount\\n mat['filler_Percent'] = mat.filler / mat.TokenCount\\n mat['Detect_Percent'] = mat.DetectCount / mat.TokenCount\\n return(mat)\\n elif output == 'array':\\n out_dict = {}\\n out_dict['Affect'] = mat[:,:,21]\\n out_dict['Posemo'] = mat[:,:,22]\\n out_dict['Negemo'] = mat[:,:,23]\\n out_dict['Anx'] = mat[:,:,24]\\n out_dict['Anger'] = mat[:,:,25]\\n out_dict['Sad'] = mat[:,:,26]\\n out_dict['Function'] = mat[:,:,0]\\n out_dict['CogProc'] = mat[:,:,32]\\n out_dict['DetectCount'] = mat[:,:,-2]\\n out_dict['TokenCount'] = mat[:,:,-1]\\n\\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\\n\\n\\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\") \\n else:\\n print(\\\"Error: Method not found!\\\")\\n elif language == 'german':\\n if method == 'dimensional':\\n if output == 'data_frame':\\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\\n mat['MeanPotency'] = mat['Potency'] / mat['DetectCount']\\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \\n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \\n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\\n return(mat)\\n elif output == 'array':\\n out_dict = {}\\n out_dict['PosVal'] = mat[:,:,0]\\n out_dict['NegVal'] = mat[:,:,1]\\n out_dict['Arousal'] = mat[:,:,2]\\n out_dict['Dominance'] = mat[:,:,3]\\n out_dict['PosCount'] = mat[:,:,4]\\n out_dict['DetectCount'] = mat[:,:,5]\\n out_dict['Imagine'] = mat[:,:,6]\\n out_dict['Potency'] = mat[:,:,7]\\n out_dict['DomPot_Count'] = mat[:,:,8]\\n out_dict['TokenCount'] = mat[:,:,9]\\n out_dict['ValSq'] = mat[:,:,10]\\n\\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\\n # Mean Values:\\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DomPot_Count'])\\n out_dict['MeanPotency'] = np.divide(out_dict['Potency'],out_dict['DomPot_Count'])\\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\\n # Percentages:\\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\")\\n elif method == 'discrete':\\n if output == 'data_frame':\\n mat['Pronoun_Percent'] = mat.Pronoun / mat.TokenCount\\n mat['I_Percent'] = mat.I / mat.TokenCount\\n mat['We_Percent'] = mat.We / mat.TokenCount\\n mat['Self_Percent'] = mat.Self / mat.TokenCount\\n mat['You_Percent'] = mat.You / mat.TokenCount\\n mat['Other_Percent'] = mat.Other / mat.TokenCount\\n mat['Negate_Percent'] = mat.Negate / mat.TokenCount\\n mat['Assent_Percent'] = mat.Assent / mat.TokenCount\\n mat['Article_Percent'] = mat.Article / mat.TokenCount\\n mat['Preps_Percent'] = mat.Preps / mat.TokenCount\\n mat['Number_Percent'] = mat.Number / mat.TokenCount\\n mat['Affect_Percent'] = mat.Affect / mat.TokenCount\\n mat['Posemo_Percent'] = mat.Posemo / mat.TokenCount\\n mat['Posfeel_Percent'] = mat.Posfeel / mat.TokenCount\\n mat['Optim_Percent'] = mat.Optim / mat.TokenCount\\n mat['Negemo_Percent'] = mat.Negemo / mat.TokenCount\\n mat['Anx_Percent'] = mat.Anx / mat.TokenCount\\n mat['Anger_Percent'] = mat.Anger / mat.TokenCount\\n mat['Sad_Percent'] = mat.Sad / mat.TokenCount\\n mat['Cogmech_Percent'] = mat.Cogmech / mat.TokenCount\\n mat['Cause_Percent'] = mat.Cause / mat.TokenCount\\n mat['Insight_Percent'] = mat.Insight / mat.TokenCount\\n mat['Discrep_Percent'] = mat.Discrep / mat.TokenCount\\n mat['Inhib_Percent'] = mat.Inhib / mat.TokenCount\\n mat['Tentat_Percent'] = mat.Tentat / mat.TokenCount\\n mat['Certain_Percent'] = mat.Certain / mat.TokenCount\\n mat['Senses_Percent'] = mat.Senses / mat.TokenCount\\n mat['See_Percent'] = mat.See / mat.TokenCount\\n mat['Hear_Percent'] = mat.Hear / mat.TokenCount\\n mat['Feel_Percent'] = mat.Feel / mat.TokenCount\\n mat['Social_Percent'] = mat.Social / mat.TokenCount\\n mat['Comm_Percent'] = mat.Comm / mat.TokenCount\\n mat['Othref_Percent'] = mat.Othref / mat.TokenCount\\n mat['Friends_Percent'] = mat.Friends / mat.TokenCount\\n mat['Family_Percent'] = mat.Family / mat.TokenCount\\n mat['Humans_Percent'] = mat.Humans / mat.TokenCount\\n mat['Time_Percent'] = mat.Time / mat.TokenCount\\n mat['Past_Percent'] = mat.Past / mat.TokenCount\\n mat['Present_Percent'] = mat.Present / mat.TokenCount\\n mat['Future_Percent'] = mat.Future / mat.TokenCount\\n mat['Space_Percent'] = mat.Space / mat.TokenCount\\n mat['Up_Percent'] = mat.Up / mat.TokenCount\\n mat['Down_Percent'] = mat.Down / mat.TokenCount\\n mat['Incl_Percent'] = mat.Incl / mat.TokenCount\\n mat['Excl_Percent'] = mat.Excl / mat.TokenCount\\n mat['Motion_Percent'] = mat.Motion / mat.TokenCount\\n mat['Occup_Percent'] = mat.Occup / mat.TokenCount\\n mat['School_Percent'] = mat.School / mat.TokenCount\\n mat['Job_Percent'] = mat.Job / mat.TokenCount\\n mat['Achieve_Percent'] = mat.Achieve / mat.TokenCount\\n mat['Leisure_Percent'] = mat.Leisure / mat.TokenCount\\n mat['Home_Percent'] = mat.Home / mat.TokenCount\\n mat['Sports_Percent'] = mat.Sports / mat.TokenCount\\n mat['TV_Percent'] = mat.TV / mat.TokenCount\\n mat['Music_Percent'] = mat.Music / mat.TokenCount\\n mat['Money_Percent'] = mat.Money / mat.TokenCount\\n mat['Metaph_Percent'] = mat.Metaph / mat.TokenCount\\n mat['Relig_Percent'] = mat.Relig / mat.TokenCount\\n mat['Death_Percent'] = mat.Death / mat.TokenCount\\n mat['Physcal_Percent'] = mat.Physcal / mat.TokenCount\\n mat['Body_Percent'] = mat.Body / mat.TokenCount\\n mat['Sexual_Percent'] = mat.Sexual / mat.TokenCount\\n mat['Eating_Percent'] = mat.Eating / mat.TokenCount\\n mat['Sleep_Percent'] = mat.Sleep / mat.TokenCount\\n mat['Groom_Percent'] = mat.Groom / mat.TokenCount\\n mat['Swear_Percent'] = mat.Swear / mat.TokenCount\\n mat['Nonfl_Percent'] = mat.Nonfl / mat.TokenCount\\n mat['Fillers_Percent'] = mat.Fillers / mat.TokenCount\\n mat['Swiss_Percent'] = mat.Swiss / mat.TokenCount\\n mat['Ideo_Percent'] = mat.Ideo / mat.TokenCount\\n mat['Personalpronomina_Percent'] = mat.Personalpronomina / mat.TokenCount\\n mat['Indefinitpronomina_Percent'] = mat.Indefinitpronomina / mat.TokenCount\\n mat['AuxiliaryVerbs_Percent'] = mat.AuxiliaryVerbs / mat.TokenCount\\n mat['Konjunktionen_Percent'] = mat.Konjunktionen / mat.TokenCount\\n mat['Adverbien_Percent'] = mat.Adverbien / mat.TokenCount\\n mat['Detect_Percent'] = mat.LIWC_Counter / mat.TokenCount\\n mat['Bedrohung_Percent'] = mat.Bedrohung / mat.TokenCount\\n return(mat)\\n\\n elif output == 'array':\\n out_dict = {}\\n out_dict['Affect'] = mat[:,:,11]\\n out_dict['Posemo'] = mat[:,:,12]\\n out_dict['Posfeel'] = mat[:,:,13]\\n out_dict['Optim'] = mat[:,:,14]\\n out_dict['Negemo'] = mat[:,:,15]\\n out_dict['Anx'] = mat[:,:,16]\\n out_dict['Anger'] = mat[:,:,17]\\n out_dict['Sad'] = mat[:,:,18]\\n out_dict['Function'] = mat[:,:,0]\\n out_dict['CogProc'] = mat[:,:,32]\\n out_dict['DetectCount'] = mat[:,:,-2]\\n out_dict['TokenCount'] = mat[:,:,-1]\\n\\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\\n out_dict['DetectPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['DetectCount'])\\n out_dict['OverallPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['TokenCount'])\\n out_dict['DetectOptimPercent'] = np.divide(out_dict['Optim'], out_dict['DetectCount'])\\n out_dict['OverallOptimPercent'] = np.divide(out_dict['Optim'], out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\\n\\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\") \\n else:\\n print(\\\"Error: Method not found!\\\") \\n elif language == 'chinese':\\n if method == 'dimensional':\\n if output == 'data_frame':\\n print(\\\"Error: This combination doesn't exist yet!\\\")\\n elif output == 'array':\\n print(\\\"Error: This combination doesn't exist yet!\\\")\\n else:\\n print(\\\"Error: Output Format not found!\\\")\\n elif method == 'discrete':\\n if output == 'data_frame':\\n print(\\\"Error: This combination doesn't exist yet!\\\")\\n elif output == 'array':\\n out_dict = {}\\n out_dict['Affect'] = mat[:,:,30]\\n out_dict['Posemo'] = mat[:,:,31]\\n out_dict['Negemo'] = mat[:,:,32]\\n out_dict['Anx'] = mat[:,:,33]\\n out_dict['Anger'] = mat[:,:,34]\\n out_dict['Sad'] = mat[:,:,35]\\n out_dict['Function'] = mat[:,:,0]\\n out_dict['CogProc'] = mat[:,:,41]\\n out_dict['DetectCount'] = mat[:,:,-2]\\n out_dict['TokenCount'] = mat[:,:,-1]\\n\\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'], out_dict['TokenCount'])\\n\\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\") \\n else:\\n print(\\\"Error: Method not found!\\\") \\n else:\\n print(\\\"Error: Language not found!\\\")\",\n \"def run_all_layers(self, img): # noqa\\n s1_outputs = [s1(img) for s1 in self.s1_units]\\n\\n # Each C1 layer pools across two S1 layers\\n c1_outputs = []\\n for c1, i in zip(self.c1_units, range(0, len(self.s1_units), 2)):\\n c1_outputs.append(c1(s1_outputs[i:i+2]))\\n\\n s2_outputs = [s2(c1_outputs) for s2 in self.s2_units]\\n c2_outputs = [c2(s2) for c2, s2 in zip(self.c2_units, s2_outputs)]\\n\\n return s1_outputs, c1_outputs, s2_outputs, c2_outputs\",\n \"def _derive_transformation_matrices(self):\\n\\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\\n if self._primaries is not None and self._whitepoint is not None:\\n npm = normalised_primary_matrix(self._primaries,\\n self._whitepoint)\\n\\n self._derived_RGB_to_XYZ_matrix = npm\\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)\",\n \"def calc_CC_operation(el_output_from_GT_W, GT_size_W, fuel_type, T_sup_K):\\n\\n (eta0, m0_exhaust_GT_kgpers) = calc_GT_operation_fullload(GT_size_W, fuel_type)\\n (eta, m_exhaust_GT_kgpers, T_exhaust_GT_K, m_fuel_kgpers) = calc_GT_operation_partload(el_output_from_GT_W,\\n GT_size_W, eta0,\\n m0_exhaust_GT_kgpers,\\n fuel_type)\\n\\n (q_output_ST_W, el_output_ST_W) = calc_ST_operation(m_exhaust_GT_kgpers, T_exhaust_GT_K, T_sup_K, fuel_type)\\n\\n LHV = LHV_NG if fuel_type == 'NG' else LHV_BG # read LHV of NG or BG\\n\\n eta_el = (el_output_from_GT_W + el_output_ST_W) / (m_fuel_kgpers * LHV)\\n eta_thermal = q_output_ST_W / (m_fuel_kgpers * LHV)\\n eta_total = eta_el + eta_thermal\\n el_output_W = el_output_ST_W + el_output_from_GT_W\\n\\n return {'el_output_W': el_output_W, 'q_output_ST_W': q_output_ST_W, 'eta_el': eta_el, 'eta_thermal': eta_thermal,\\n 'eta_total': eta_total}\",\n \"def coeff_display_M202(Nstar=1,seeing=[0.9,0.,0.],npix=npix,zenith=0,filter='r', theta=0., phi=0,corrector='corrector',x=0.,y=0.,z=0.,zernike_max_order=20,regular=False):\\n hdu = genImgVallCCD(Nstar=Nstar,seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta,phi=phi, corrector=corrector,x=x,y=y,z=z,regular=regular)\\n nn = len(hdu)\\n data = []\\n colnames = ['x','y','M20','M22','M31','M33']\\n for hdui in hdu[1:]:\\n Nobj = hdui.data.shape[0]\\n M20=np.zeros(Nobj)\\n M22=np.zeros(Nobj).astype(complex)\\n M31=np.zeros(Nobj).astype(complex)\\n M33=np.zeros(Nobj).astype(complex)\\n for i in range(Nobj):\\n img = hdui.data[i][4:].reshape(npix,npix)\\n img = rebin(img,(40,40))\\n M20,M22,M31,M33=complexMoments(data=img,sigma=4.)\\n x=hdui.header['ccdXcen']\\n y=hdui.header['ccdYcen']\\n data.append([x,y,np.median(M20), np.median(M22), np.median(M31), np.median(M33)])\\n data=np.array(data) \\n betaAll=[]\\n betaErrAll=[]\\n R2adjAll=[]\\n beta,betaErr,R2_adj,fitted = zernikeFit(data[:,0].real,data[:,1].real,data[:,2].real,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n for i in range(3,6):\\n beta,betaErr,R2_adj,fitted = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].real,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n beta,betaErr,R2_adj,fitted = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].imag,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n betaAll = np.array(betaAll)\\n betaErrAll = np.array(betaErrAll)\\n R2adjAll = np.array(R2adjAll)\\n ind = np.arange(len(betaAll[0]))\\n momname = ('M20','M22.Real','M22.imag','M31.real','M31.imag','M33.real','M33.imag')\\n fmtarr = ['bo-','ro-','go-','co-','mo-','yo-','ko-']\\n pl.figure(figsize=(17,7))\\n for i in range(3):\\n pl.subplot(4,1,i+1)\\n pl.errorbar(ind[1:],betaAll[i][1:],yerr = betaErrAll[i][1:],fmt=fmtarr[i])\\n if i == 0:\\n pl.title('x: '+str(hdu[0].header['x'])+' y: '+str(hdu[0].header['y'])+' z: '+str(hdu[0].header['z'])+' tilt: '+str(hdu[0].header['theta'])+' fwhm: '+str(hdu[0].header['s_fwhm'])+' e1: '+str(hdu[0].header['e1'])+' e2: '+str(hdu[0].header['e2']))\\n pl.grid()\\n pl.xlim(-1,len(betaAll[i])+1)\\n pl.ylim(min(betaAll[i][1:])-0.5,max(betaAll[i][1:])+0.5)\\n #pl.ylim(-0.1,0.1)\\n pl.xticks(ind,('','','','','','','','','','','','','','','','','','','',''))\\n pl.ylabel(momname[i])\\n pl.xticks(ind,('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20'),rotation=90)\\n pl.xlabel('Zernike Coefficients')\\n return betaAll,betaErrAll\",\n \"def residual_net_old(total_depth, data_layer_params, num_classes = 1000, acclayer = True):\\n # figure out network structure\\n net_defs = {\\n 18:([2, 2, 2, 2], \\\"standard\\\"),\\n 34:([3, 4, 6, 3], \\\"standard\\\"),\\n 50:([3, 4, 6, 3], \\\"bottleneck\\\"),\\n 101:([3, 4, 23, 3], \\\"bottleneck\\\"),\\n 152:([3, 8, 36, 3], \\\"bottleneck\\\"),\\n }\\n assert total_depth in net_defs.keys(), \\\"net of depth:{} not defined\\\".format(total_depth)\\n\\n nunits_list, unit_type = net_defs[total_depth] # nunits_list a list of integers indicating the number of layers in each depth.\\n nouts = [64, 128, 256, 512] # same for all nets\\n\\n # setup the first couple of layers\\n n = caffe.NetSpec()\\n n.data, n.label = L.Python(module = 'beijbom_caffe_data_layers', layer = 'ImageNetDataLayer',\\n ntop = 2, param_str=str(data_layer_params))\\n n.conv1, n.bn1, n.lrn1 = conv_bn(n.data, ks = 7, stride = 2, nout = 64, pad = 3)\\n n.relu1 = L.ReLU(n.lrn1, in_place=True)\\n n.pool1 = L.Pooling(n.relu1, stride = 2, kernel_size = 3)\\n \\n # make the convolutional body\\n for nout, nunits in zip(nouts, nunits_list): # for each depth and nunits\\n for unit in range(1, nunits + 1): # for each unit. Enumerate from 1.\\n s = str(nout) + '_' + str(unit) + '_' # layer name prefix\\n if unit_type == \\\"standard\\\":\\n residual_standard_unit_old(n, nout, s, newdepth = unit is 1 and nout > 64)\\n else:\\n residual_bottleneck_unit_old(n, nout, s, newdepth = unit is 1)\\n \\n # add the end layers \\n n.global_pool = L.Pooling(n.__dict__['tops'][n.__dict__['tops'].keys()[-1]], pooling_param = dict(pool = 1, global_pooling = True))\\n n.score = L.InnerProduct(n.global_pool, num_output = num_classes,\\n param=[dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0)])\\n n.loss = L.SoftmaxWithLoss(n.score, n.label)\\n if acclayer:\\n n.accuracy = L.Accuracy(n.score, n.label)\\n\\n return n\",\n \"def main():\\n conf_matrix1 = one_vs_all()\\n conf_matrix2 = all_vs_all()\\n results = my_info() + '\\\\t\\\\t'\\n results += np.array_str(np.diagonal(conf_matrix1)) + '\\\\t\\\\t'\\n results += np.array_str(np.diagonal(conf_matrix2))\\n print results + '\\\\t\\\\t'\\n\\n # sum = 0\\n #\\n # for i in range(len(conf_matrix1)):\\n # sum += conf_matrix1[i][i]\\n #\\n # print \\\"One-vs-All corecct classifications: \\\", sum\\n #\\n # sum = 0\\n #\\n # for i in range(len(conf_matrix2)):\\n # sum += conf_matrix2[i][i]\\n #\\n # print \\\"All-vs-All correct classificatinos: \\\", sum\\n\\n #print(\\\"onevsall\\\")\\n #print_latex_table(conf_matrix1)\\n #print(\\\"allvsall\\\")\\n #print_latex_table(conf_matrix2)\",\n \"def _final_aggregation(means_x: Tensor, means_y: Tensor, vars_x: Tensor, vars_y: Tensor, corrs_xy: Tensor, nbs: Tensor) ->Tuple[Tensor, Tensor, Tensor, Tensor, Tensor, Tensor]:\\n mx1, my1, vx1, vy1, cxy1, n1 = means_x[0], means_y[0], vars_x[0], vars_y[0], corrs_xy[0], nbs[0]\\n for i in range(1, len(means_x)):\\n mx2, my2, vx2, vy2, cxy2, n2 = means_x[i], means_y[i], vars_x[i], vars_y[i], corrs_xy[i], nbs[i]\\n nb = n1 + n2\\n mean_x = (n1 * mx1 + n2 * mx2) / nb\\n mean_y = (n1 * my1 + n2 * my2) / nb\\n element_x1 = (n1 + 1) * mean_x - n1 * mx1\\n vx1 += (element_x1 - mx1) * (element_x1 - mean_x) - (element_x1 - mean_x) ** 2\\n element_x2 = (n2 + 1) * mean_x - n2 * mx2\\n vx2 += (element_x2 - mx2) * (element_x2 - mean_x) - (element_x2 - mean_x) ** 2\\n var_x = vx1 + vx2\\n element_y1 = (n1 + 1) * mean_y - n1 * my1\\n vy1 += (element_y1 - my1) * (element_y1 - mean_y) - (element_y1 - mean_y) ** 2\\n element_y2 = (n2 + 1) * mean_y - n2 * my2\\n vy2 += (element_y2 - my2) * (element_y2 - mean_y) - (element_y2 - mean_y) ** 2\\n var_y = vy1 + vy2\\n cxy1 += (element_x1 - mx1) * (element_y1 - mean_y) - (element_x1 - mean_x) * (element_y1 - mean_y)\\n cxy2 += (element_x2 - mx2) * (element_y2 - mean_y) - (element_x2 - mean_x) * (element_y2 - mean_y)\\n corr_xy = cxy1 + cxy2\\n mx1, my1, vx1, vy1, cxy1, n1 = mean_x, mean_y, var_x, var_y, corr_xy, nb\\n return mean_x, mean_y, var_x, var_y, corr_xy, nb\",\n \"def __call__(self, affine, representations_list, aatype):\\n act = [\\n common_modules.Linear( # pylint: disable=g-complex-comprehension\\n self.config.num_channel,\\n name='input_projection')(jax.nn.relu(x))\\n for x in representations_list\\n ]\\n # Sum the activation list (equivalent to concat then Linear).\\n act = sum(act)\\n\\n final_init = 'zeros' if self.global_config.zero_init else 'linear'\\n\\n # Mapping with some residual blocks.\\n for _ in range(self.config.num_residual_block):\\n old_act = act\\n act = common_modules.Linear(\\n self.config.num_channel,\\n initializer='relu',\\n name='resblock1')(\\n jax.nn.relu(act))\\n act = common_modules.Linear(\\n self.config.num_channel,\\n initializer=final_init,\\n name='resblock2')(\\n jax.nn.relu(act))\\n act += old_act\\n\\n # Map activations to torsion angles. Shape: (num_res, 14).\\n num_res = act.shape[0]\\n unnormalized_angles = common_modules.Linear(\\n 14, name='unnormalized_angles')(\\n jax.nn.relu(act))\\n unnormalized_angles = jnp.reshape(\\n unnormalized_angles, [num_res, 7, 2])\\n angles = l2_normalize(unnormalized_angles, axis=-1)\\n\\n outputs = {\\n 'angles_sin_cos': angles, # jnp.ndarray (N, 7, 2)\\n 'unnormalized_angles_sin_cos':\\n unnormalized_angles, # jnp.ndarray (N, 7, 2)\\n }\\n\\n # Map torsion angles to frames.\\n backb_to_global = r3.rigids_from_quataffine(affine)\\n\\n # Jumper et al. (2021) Suppl. Alg. 24 \\\"computeAllAtomCoordinates\\\"\\n\\n # r3.Rigids with shape (N, 8).\\n all_frames_to_global = all_atom.torsion_angles_to_frames(\\n aatype,\\n backb_to_global,\\n angles)\\n\\n # Use frames and literature positions to create the final atom coordinates.\\n # r3.Vecs with shape (N, 14).\\n pred_positions = all_atom.frames_and_literature_positions_to_atom14_pos(\\n aatype, all_frames_to_global)\\n\\n outputs.update({\\n 'atom_pos': pred_positions, # r3.Vecs (N, 14)\\n 'frames': all_frames_to_global, # r3.Rigids (N, 8)\\n })\\n return outputs\",\n \"def forward_propagate(self):\\n for i in range(0, len(self.output_layer)):\\n output = 0\\n\\n # Loop through each Neuron in the hidden layer\\n for neuron in self.hidden_layer:\\n output += neuron.weights[i] * neuron.output\\n\\n # Update summation for output classifier\\n self.output_layer[i] = output\",\n \"def _inexact_alm_l1(imgflt_stack,options):\\n # Get basic image information and reshape input\\n img_width = imgflt_stack.shape[0]\\n img_height = imgflt_stack.shape[1]\\n img_size = img_width* img_height\\n img_3d = imgflt_stack.shape[2]\\n imgflt_stack = np.reshape(imgflt_stack,(img_size, img_3d))\\n options['weight'] = np.reshape(options['weight'],imgflt_stack.shape)\\n\\n # Matrix normalization factor\\n temp = np.linalg.svd(imgflt_stack,full_matrices=False,compute_uv=False)\\n norm_two = np.float64(temp[0])\\n del temp\\n\\n # A is a low rank matrix that is being solved for\\n A = np.zeros(imgflt_stack.shape,dtype=np.float64)\\n A_coeff = np.ones((1, img_3d),dtype=np.float64) # per image scaling coefficient, accounts for things like photobleaching\\n A_offset = np.zeros((img_size,1),dtype=np.float64) # offset per pixel across all images\\n\\n # E1 is the additive error. Since the goal is determining the background signal, this is the real signal at each pixel\\n E1 = np.zeros(imgflt_stack.shape,dtype=np.float64)\\n\\n # Normalization factors\\n ent1 = np.float64(1) # flatfield normalization\\n ent2 = np.float64(10) # darkfield normalization\\n\\n # Weights\\n weight_upd = _dct2(np.mean(np.reshape(A,(img_width, img_height, img_3d)),2))\\n\\n # Initialize gradient and weight normalization factors\\n Y1 = np.float64(0)\\n mu = np.float64(12.5)/norm_two\\n mu_bar = mu * 10**7\\n rho = np.float64(1.5)\\n\\n # Frobenius norm\\n d_norm = np.linalg.norm(imgflt_stack,'fro')\\n\\n # Darkfield upper limit and offset\\n B1_uplimit = np.min(imgflt_stack)\\n B1_offset = np.float64(0)\\n\\n # Perform optimization\\n iternum = 0\\n converged = False\\n while not converged:\\n iternum += 1\\n\\n # Calculate the flatfield using existing weights, coefficients, and offsets\\n W_idct_hat = _idct2(weight_upd)\\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\\n temp_W = np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\\n\\n # Update the weights\\n temp_W = np.reshape(temp_W,(img_width, img_height, img_3d))\\n temp_W = np.mean(temp_W,2)\\n weight_upd = weight_upd + _dct2(temp_W)\\n weight_upd = np.max(np.reshape(weight_upd - options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0) + np.min(np.reshape(weight_upd + options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0)\\n W_idct_hat = _idct2(weight_upd)\\n\\n # Calculate the flatfield using updated weights\\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\\n\\n # Determine the error\\n E1 = E1 + np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\\n E1 = np.max(np.reshape(E1 - options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0) + np.min(np.reshape(E1 + options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0)\\n\\n # Calculate the flatfield coefficients by subtracting the errors from the original data\\n R1 = imgflt_stack-E1\\n A_coeff = np.reshape(np.mean(R1,0)/np.mean(R1),(1, img_3d))\\n A_coeff[A_coeff<0] = 0 # pixel values should never be negative\\n\\n # Calculate the darkfield component if specified by the user\\n if options['darkfield']:\\n # Get images with predominantly background pixels\\n validA1coeff_idx = np.argwhere(A_coeff<1)[:,1]\\n R1_upper = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1)).astype(np.float64)>(np.float64(np.mean(W_idct_hat))-np.float64(10**-5)))[:,0],:]\\n R1_upper = np.mean(R1_upper[:,validA1coeff_idx],0)\\n R1_lower = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1)) options['max_iterations']:\\n converged = True\\n\\n # Calculate final darkfield image\\n A_offset = A_offset + B1_offset * np.reshape(W_idct_hat,(-1,1))\\n\\n return A,E1,A_offset\",\n \"def reconstruct(X_input, X_mean, X_std, Y, P, e_scaled, x_col = 0, y_col = 1, dimensions = [0, 1, 2, 3]):\\n\\t# Reconstruction degrees information retention (~25%, ~50%, ~75%, and ~100%).\\n\\tfor d in dimensions:\\n\\t\\t# Reconstruct \\n\\t\\tY_proj = Y.iloc[:,0:(d + 1)]\\n\\t\\tX_rec = (Y_proj @ P.iloc[:,0:(d + 1)].T) * X_std + X_mean\\n\\t\\tX_rec.columns = X_input.columns\\n\\n\\t\\t# Cumulate percentage information retained\\n\\t\\tdata_retained = e_scaled[range(d + 1)].sum() * 100\\n\\n\\t\\tml.plt.figure()\\n\\t\\tml.plt.title(f'Raw vs. Reconstructed D = {d + 1}')\\n\\t\\tml.sns.scatterplot(data = X_input, x = X_input.iloc[:, x_col], y = X_input.iloc[:, y_col], alpha = 0.5, color = 'k', label = 'Raw Data (100%)')\\n\\t\\tml.sns.scatterplot(data = X_rec, x = X_rec.iloc[:, x_col], y = X_rec.iloc[:, y_col], alpha = 0.5, color = 'r', label = f'Reconstructed Data ({data_retained: .2f}%)')\",\n \"def connector_mediation(task):\\n\\tatlas = 'power'\\n\\tproject='hcp'\\n\\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\\n\\tsubjects = np.load('%s/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %(homedir,'hcp',task,atlas))\\n\\tstatic_results = graph_metrics(subjects,task,atlas,run_version='fz')\\n\\tmatrices = static_results['matrices']\\n\\tsubject_pcs = static_results['subject_pcs']\\n\\tsubject_mods = static_results['subject_mods']\\n\\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\\n\\tfor i in range(subject_pcs.shape[1]):\\n\\t\\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\\n\\tmean_conn = np.nanmean(matrices,axis=0)\\n\\te_tresh = np.percentile(mean_conn,85)\\n\\tsubject_pcs[np.isnan(subject_pcs)] = 0.0\\n\\tm = np.zeros((264,264,264))\\n\\tpool = Pool(40)\\n\\tfor n in range(264):\\n\\t\\tprint n\\n\\t\\tsys.stdout.flush()\\n\\t\\tvariables = []\\n\\t\\tfor i,j in combinations(range(264),2):\\n\\t\\t\\tvariables.append(pd.DataFrame(data={'pc':subject_pcs[:,n],'weight':matrices[:,i,j],'q':subject_mods},index=range(len(subject_pcs))))\\n\\t\\tresults = pool.map(multi_med,variables)\\n\\t\\tfor r,i in zip(results,combinations(range(264),2)):\\n\\t\\t\\tm[n,i[0],i[1]] = r\\n\\t\\t\\tm[n,i[1],i[0]] = r\\n\\t\\tnp.save('/home/despoB/mb3152/dynamic_mod/results/full_med_matrix_new_%s.npy'%(task),m)\",\n \"def TNFR1_to_SecondaryComplex():\\n \\n Parameter('TNFa_0' , 5000) # 3000 corresponds to 50ng/ml TNFa\\n Parameter('TNFR1_0' , 200) # 200 receptors per cell\\n Parameter('TRADD_0' , 1000) # molecules per cell (arbitrarily assigned)1000\\n Parameter('CompI_0' , 0) # complexes per cell\\n Parameter('RIP1_0' , 20000) # molecules per cell 20000\\n Parameter('NFkB_0' , 0) # molecules per cell\\n \\n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\\n Initial(RIP1(bDD=None, bRHIM = None, state = 'ub'), RIP1_0) # RIP1\\n Initial(NFkB(bf=None), NFkB_0)\\n\\n # =========================================\\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\\n # -----------------------------------------\\n # TNFa+ TNFR1 <-> TNFa:TNFR1\\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub \\n \\n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\\n # [active]CompI:RIP1 >> [active]CompI + RIP1\\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\\n\\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it. \\n\\n # ------------------------------------------\\n \\n # -------------Complex I assembly----------------\\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [KF, KR])\\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [KF, KR])\\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), KC)\\n \\n # --------------Complex I - RIP1 Modification-----------------\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[KF, KR])\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR]) \\n \\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'),KC)\\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [Parameter('k2', 0), KR])\\n #Rule('RIP1_rel', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod') + RIP1(bDD=None, bRHIM = None, state = 'unmod'), KC3)\\n #bind(CompI(bDD=None, state = 'mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR])\\n #Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod'),KC3)\\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), KC)\\n Rule('NFkB_expression', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), KE)\\n # --------------RIP1 Ubiquitination---------------------------\\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), KC2)\\n # Rule('RIP1_deUb', RIP1(bDD=None, bRHIM = None, state='ub')>> RIP1(bDD=None, bRHIM = None, state='unmod'), KR)\",\n \"def forward_pass(X,architecture):\\n \\n architecture['layer1'][0] = X\\n kernel_shape1 = architecture['layer1'][7]\\n stride1 = architecture['layer1'][8]\\n if kernel_shape1 is not None and not isinstance(kernel_shape1,int):\\n X_input_1_im2col,imX = im2col(X,kernel_shape1,stride1,im_needed = False, shape_specified = True)\\n architecture['layer1'][4] = X_input_1_im2col\\n else:\\n architecture['layer1'][4] = None\\n\\n for layer in range(len(architecture)): # Feedforward from the first till the second last layer\\n X_input,X_output,weightsi,biasi,X_input_1_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imx = architecture['layer{}'.format(layer+1)]\\n\\n if operationi == 'conv_bn_relu':\\n conv_output = relu(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'conv_relu':\\n conv_output = relu(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'conv_bn_sigmoid':\\n conv_output = sigmoid(BatchNorm(torch.t(X_input_1_im2col).mm(weightsi) + biasi))\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'conv_sigmoid':\\n conv_output = sigmoid(torch.t(X_input_1_im2col).mm(weightsi) + biasi)\\n conv_output = torch.reshape(conv_output,output_shapei)\\n architecture['layer{}'.format(layer+1)][1] = conv_output # resetting output as convolved shape\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = conv_output # resetting intput of next layer as convolved shape\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n if operationi__1 == 'maxpool':\\n architecture['layer{}'.format(layer+2)][4] = maxpool_im2col(conv_output,kernel_shapei__1,stridei__1)\\n else:\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(conv_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n # resetting input im2col of next layer as the im2col of the output of this layer\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'maxpool':\\n maxpool_output = maxpool(X_input,kernel_shapei,stridei)\\n\\n maxpool_output = torch.reshape(maxpool_output,output_shapei)\\n\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = maxpool_output\\n kernel_shapei__1 = architecture['layer{}'.format(layer+2)][7]\\n stridei__1 = architecture['layer{}'.format(layer+2)][8]\\n if kernel_shapei__1 is not None and not isinstance(kernel_shapei__1,int):\\n architecture['layer{}'.format(layer+2)][4],imX = im2col(maxpool_output,kernel_shapei__1,stridei__1,im_needed = False, shape_specified = True)\\n else:\\n architecture['layer{}'.format(layer+2)][4] = None\\n elif operationi == 'flatten_dense_relu':\\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'relu',initialise_weights = False)\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = output\\n elif operationi == 'flatten_dense_none':\\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'none',initialise_weights = False)\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = output\\n elif operationi == 'flatten_dense_sigmoid':\\n # kernel_shapei in this case refers to the output channels: stride for dense layer will be None\\n output = flatten_and_dense(X_input,kernel_shapei,weightsi,biasi,activation = 'sigmoid',initialise_weights = False)\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer != len(architecture) - 1:\\n architecture['layer{}'.format(layer+2)][0] = output\\n elif operationi == 'softmax':\\n Xin = architecture['layer{}'.format(layer+1)][0]\\n output = softmax(Xin).squeeze()\\n architecture['layer{}'.format(layer+1)][1] = output\\n if layer == len(architecture) - 1:\\n y_pred = architecture['layer{}'.format(len(architecture))][1]\\n \\n return y_pred\",\n \"def _apply_individual_nbody1_accumulate_python(\\n coeff: 'Nparray', ocoeff: 'Nparray', icoeff: 'Nparray',\\n amap: 'Nparray', btarget: 'Nparray', bsource: 'Nparray',\\n bparity: 'Nparray') -> None:\\n for sourcea, targeta, paritya in amap:\\n ocoeff[targeta, btarget] += coeff * paritya * numpy.multiply(\\n icoeff[sourcea, bsource], bparity)\",\n \"def explain(self):\\n # build the 2 versions of the model\\n model = self.build_model()\\n last_conv_model = self.build_cut_model()\\n\\n for i, label_name in enumerate(self.label_names):\\n # This is the algorithm for the last convolution layer's tensor image\\n # Get the index of the image that was classified correctly with the most confidence for the class\\n predicted_col_proba = np.array(self.predicted_labels)[0][:, i]\\n predicted_col_argsort = predicted_col_proba.argsort()[::-1]\\n predicted_col = (predicted_col_proba > 0.2).astype(int)\\n true_col = self.true_labels[:, 0]\\n\\n representative_image_index = None\\n for most_probable_arg_index in predicted_col_argsort:\\n if predicted_col[most_probable_arg_index] == true_col[most_probable_arg_index]:\\n representative_image_index = most_probable_arg_index\\n break\\n\\n # Resize the image to fit the neural network and keep the original resized image\\n original_img = io.imread('{}/{}/{}'.format(path_to_img_directory, self.ex_format, np.array(self.image_names)[representative_image_index]))\\n original_img = cv2.normalize(original_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n original_img = cv2.resize(original_img, dsize=(self.ex_input_size, self.ex_input_size), interpolation=cv2.INTER_CUBIC)\\n img = np.expand_dims(original_img, axis=0)\\n original_img = original_img[:, :, :3]\\n\\n # Get the output of the neural network for this image as a tensor\\n model.predict(np.array(img))\\n class_output = model.output[:, i]\\n last_conv_layer = model.get_layer(self.ex_last_conv_layer_name1).output\\n # if self.model_name == 'vit':\\n # last_conv_layer = tf.nn.relu(tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024)))\\n\\n # Get the output for the cut model\\n cut_img = last_conv_model.predict(np.array(img))[0]\\n if self.model_name == 'vit':\\n cut_img = np.reshape(cut_img[:256, :], (16, 16, 1024))\\n cut_img = np.mean(cut_img, axis=-1)\\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n if self.model_name == 'vit':\\n cut_img[0, 0] = np.mean(cut_img)\\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n cut_img = cv2.resize(cut_img, (self.ex_input_size, self.ex_input_size))\\n\\n # This is the algorithm of the Grad-CAM model\\n # Refine the output of the last convolutional layer according to the class output\\n grads = K.gradients(class_output, last_conv_layer)[0]\\n if self.model_name == 'vit':\\n last_conv_layer = tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024))\\n last_conv_layer = last_conv_layer / tf.norm(last_conv_layer)\\n\\n grads = tf.reshape(grads[:, :256, :], (-1, 16, 16, 1024))\\n grads = grads / tf.norm(grads)\\n\\n pooled_grads = K.mean(grads, axis=(0, 1, 2))\\n iterate = K.function([model.input], [pooled_grads, last_conv_layer[0]])\\n pooled_grads_value, conv_layer_output_value = iterate([img])\\n for j in range(self.ex_last_conv_layer_filter_number):\\n conv_layer_output_value[:, :, j] *= pooled_grads_value[j]\\n\\n # Create a 16x16 heatmap and scale it to the same size as the original image\\n heatmap = np.mean(conv_layer_output_value, axis=-1)\\n heatmap = np.maximum(heatmap, 0)\\n heatmap /= np.max(heatmap)\\n heatmap = cv2.resize(heatmap, (self.ex_input_size, self.ex_input_size))\\n heatmap = np.uint8(255 * heatmap)\\n heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)\\n heatmap = cv2.normalize(heatmap, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n superimposed_img = cv2.addWeighted(original_img, 0.7, heatmap, 0.4, 0)\\n\\n # save the original image\\n plt.matshow(original_img)\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'original', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\\n\\n # save the cut image\\n plt.matshow(cut_img, cmap=plt.get_cmap('Spectral'))\\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'cut', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\\n\\n # save the superimposed gradcam image\\n plt.matshow(superimposed_img, cmap=plt.get_cmap('Spectral'))\\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'gradcam', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\",\n \"def process(self, mat):\",\n \"def UpdateLayers(self):\\n pass\",\n \"def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\\n dtype=np.float32):\\n self.params = {}\\n self.reg = reg\\n self.dtype = dtype\\n \\n ############################################################################\\n # TODO: Initialize weights and biases for the three-layer convolutional #\\n # network. Weights should be initialized from a Gaussian with standard #\\n # deviation equal to weight_scale; biases should be initialized to zero. #\\n # All weights and biases should be stored in the dictionary self.params. #\\n # Store weights and biases for the convolutional layer using the keys 'W1' #\\n # and 'b1'; use keys 'W2' and 'b2' for the weights and biases of the #\\n # hidden affine layer, and keys 'W3' and 'b3' for the weights and biases #\\n # of the output affine layer. #\\n ############################################################################ \\n C, H, W = input_dim;\\n\\n # Dimensions of data output by convolutional layer\\n S = 1; pad = (filter_size - 1) / 2; # Stride and image padding\\n hconv = (H - filter_size + 2*pad)/S + 1;\\n wconv = (W - filter_size + 2*pad)/S + 1;\\n\\n # Get dimensions of 2x2 max-pool output\\n hmp = hconv / 2;\\n wmp = wconv / 2;\\n\\n # Get dimensions of vector fed into affine layer\\n # Convert maxpool output by using np.reshape(v1,(N,-1))\\n # Recover by using np.reshape(dv1,v1.shape)\\n laff = hmp*wmp*num_filters;\\n\\n # Determine starting weight and bias matrices\\n self.params['W1'] = weight_scale * np.random.randn(num_filters, C, filter_size, filter_size);\\n self.params['b1'] = np.zeros(num_filters);\\n self.params['W2'] = weight_scale * np.random.randn(laff, hidden_dim);\\n self.params['b2'] = np.zeros(hidden_dim);\\n self.params['W3'] = weight_scale * np.random.rand(hidden_dim,num_classes);\\n self.params['b3'] = np.zeros(num_classes);\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n for k, v in self.params.iteritems():\\n self.params[k] = v.astype(dtype)\",\n \"def reduce(self,predictor):\\n span,stack_top=self\\n s0,s1,s2=stack_top\\n if s0==None or s1==None:return []\\n p_span,pstack=predictor\\n\\n print('reduce>>>>>>>>',self)\\n\\n rtn= [\\n (ord('L'),pickle.dumps(( # ind\\n (p_span[0],span[1]), #span\\n ((s1[0],s1[1],s0[0]),pstack[1],pstack[2]))), ##\\n ),\\n (ord('R'),pickle.dumps(( #\\n (p_span[0],span[1]),\\n ((s0[0],s1[0],s0[2]),pstack[1],pstack[2]))),\\n ),\\n ]\\n return rtn\",\n \"def compute_model(self, A_on_basis_vecs, B_on_standard_basis_array,\\n C_on_basis_vecs):\\n self.reduce_A(A_on_basis_vecs)\\n self.reduce_B(B_on_standard_basis_array)\\n self.reduce_C(C_on_basis_vecs)\\n return self.A_reduced, self.B_reduced, self.C_reduced\"\n]"},"negative_scores":{"kind":"list like","value":["0.5332517","0.532662","0.53114045","0.5299733","0.52236503","0.5153382","0.51122165","0.5084768","0.50838053","0.50646925","0.505108","0.5036968","0.5031033","0.50278485","0.50072664","0.50027597","0.4986492","0.49739137","0.49683747","0.4963426","0.49604002","0.49494305","0.49310955","0.4921163","0.49145284","0.48912558","0.48815235","0.4856885","0.48517102","0.48389143","0.4831509","0.4829985","0.4827887","0.48197114","0.48061967","0.48023662","0.47967127","0.47875616","0.47867706","0.4785091","0.47753817","0.4767045","0.47656783","0.47571987","0.4749793","0.47479817","0.47443974","0.47426072","0.47353458","0.47317523","0.47168535","0.4709121","0.4708894","0.47077373","0.47036442","0.46909848","0.46878287","0.46877098","0.4678217","0.46777534","0.46741447","0.4671688","0.46692717","0.4659111","0.46551213","0.46521404","0.46508342","0.4645591","0.46442693","0.4643926","0.463433","0.4633213","0.46314275","0.46307734","0.46285093","0.4628346","0.4627117","0.46252033","0.46219423","0.46199664","0.461906","0.46120423","0.46058103","0.4604493","0.46026528","0.46025863","0.45922992","0.45913047","0.45906913","0.45880038","0.45873788","0.45850646","0.45788586","0.45783308","0.4575647","0.4575577","0.45714313","0.45685312","0.45674506","0.45667243"],"string":"[\n \"0.5332517\",\n \"0.532662\",\n \"0.53114045\",\n \"0.5299733\",\n \"0.52236503\",\n \"0.5153382\",\n \"0.51122165\",\n \"0.5084768\",\n \"0.50838053\",\n \"0.50646925\",\n \"0.505108\",\n \"0.5036968\",\n \"0.5031033\",\n \"0.50278485\",\n \"0.50072664\",\n \"0.50027597\",\n \"0.4986492\",\n \"0.49739137\",\n \"0.49683747\",\n \"0.4963426\",\n \"0.49604002\",\n \"0.49494305\",\n \"0.49310955\",\n \"0.4921163\",\n \"0.49145284\",\n \"0.48912558\",\n \"0.48815235\",\n \"0.4856885\",\n \"0.48517102\",\n \"0.48389143\",\n \"0.4831509\",\n \"0.4829985\",\n \"0.4827887\",\n \"0.48197114\",\n \"0.48061967\",\n \"0.48023662\",\n \"0.47967127\",\n \"0.47875616\",\n \"0.47867706\",\n \"0.4785091\",\n \"0.47753817\",\n \"0.4767045\",\n \"0.47656783\",\n \"0.47571987\",\n \"0.4749793\",\n \"0.47479817\",\n \"0.47443974\",\n \"0.47426072\",\n \"0.47353458\",\n \"0.47317523\",\n \"0.47168535\",\n \"0.4709121\",\n \"0.4708894\",\n \"0.47077373\",\n \"0.47036442\",\n \"0.46909848\",\n \"0.46878287\",\n \"0.46877098\",\n \"0.4678217\",\n \"0.46777534\",\n \"0.46741447\",\n \"0.4671688\",\n \"0.46692717\",\n \"0.4659111\",\n \"0.46551213\",\n \"0.46521404\",\n \"0.46508342\",\n \"0.4645591\",\n \"0.46442693\",\n \"0.4643926\",\n \"0.463433\",\n \"0.4633213\",\n \"0.46314275\",\n \"0.46307734\",\n \"0.46285093\",\n \"0.4628346\",\n \"0.4627117\",\n \"0.46252033\",\n \"0.46219423\",\n \"0.46199664\",\n \"0.461906\",\n \"0.46120423\",\n \"0.46058103\",\n \"0.4604493\",\n \"0.46026528\",\n \"0.46025863\",\n \"0.45922992\",\n \"0.45913047\",\n \"0.45906913\",\n \"0.45880038\",\n \"0.45873788\",\n \"0.45850646\",\n \"0.45788586\",\n \"0.45783308\",\n \"0.4575647\",\n \"0.4575577\",\n \"0.45714313\",\n \"0.45685312\",\n \"0.45674506\",\n \"0.45667243\"\n]"},"document_score":{"kind":"string","value":"0.45976505"},"document_rank":{"kind":"string","value":"86"}}},{"rowIdx":1689,"cells":{"query":{"kind":"string","value":"Reads choice and directs on a path depending on input"},"document":{"kind":"string","value":"def main_page(self):\n choice = \"\"\n while choice != \"x\":\n header, main_menu, choices, underline = self.__get_format.main_menu_format()\n choice = self.__main_menu.main_page(header,main_menu,choices,underline)\n if choice == \"1\":\n self.__rent_controller.Rent_page()\n elif choice == \"2\":\n try_again = \"\"\n while try_again != \"n\":\n try_again, valid = self.__salesman_controller.sign_in_page()\n if valid == True:\n self.__salesman_controller.salesman_menu()\n elif choice == \"3\":\n self.__order_controller.find_order_process(page=2)\n elif choice == \"i\":\n self.__information_controller.information_page()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def warriorPath1():\n with open('stories/warrior/warrior_path1.txt') as f:\n path1 = f.read()\n print(path1.format(NAME))\n while True:\n print(\"What will you do?\")\n print(\"1. Don't light the torch and keep walking\")\n print(\"2. Light the torch with magic\")\n secondPathChoice = input(\"1, 2\\n\")\n # Input validation\n while secondPathChoice != \"1\" and secondPathChoice != \"2\":\n print(\"Invalid input\")\n secondPathChoice = input(\"1, 2\\n\")\n\n if secondPathChoice == \"1\":\n warriorPath1_1()\n break\n elif secondPathChoice == \"2\":\n warriorPath1_2()","def choose_file():\n chdir(getcwd()+'/data/US')\n f = []\n for (dirpath, dirnames, filenames) in walk(getcwd()):\n f.extend(filenames)\n print('Which file do you want to work on?')\n for i in f:\n print(str(f.index(i)) + ' - ' + i)\n while True:\n try:\n return f[int(input('Type its number: '))]\n except ValueError or IndexError:\n print('Invalid input.')","def warriorPath1_1_1_2():\n with open('stories/warrior/warrior_path1_1_1_2.txt') as f:\n path1_1_1_2 = f.read()\n print(path1_1_1_2.format(NAME))\n print(\"1. Take the Caldun\")\n print(\"2. Leave\")\n fifthPathChoice = input(\"1, 2\\n\")\n # Input validation\n while fifthPathChoice != \"1\" and fifthPathChoice != \"2\":\n print(\"Invalid input\")\n fifthPathChoice = input(\"1, 2\\n\")\n\n if fifthPathChoice == \"1\":\n # Function called from gmail_sheet.py\n update_sheet_warrior_ending_1()\n # Display story\n with open('stories/warrior/warrior_end_1.txt') as f:\n end1 = f.read()\n print(end1.format(NAME))\n elif fifthPathChoice == \"2\":\n # Function called from gmail_sheet.py\n update_sheet_warrior_ending_2()\n # Display story\n with open('stories/warrior/warrior_end_2.txt') as f:\n end2 = f.read()\n print(end2.format(NAME))","def choose_file(self):\n pass","def warriorPath1_1_1():\n with open('stories/warrior/warrior_path1_1_1.txt') as f:\n path1_1_1 = f.read()\n print(path1_1_1.format(NAME))\n while True:\n print(\"What will you do?\")\n print(\"1. Collect courage\")\n print(\"2. Jump down\")\n fourthPathChoice = input(\"1, 2\\n\")\n # Input validation\n while fourthPathChoice != \"1\" and fourthPathChoice != \"2\":\n print(\"Invalid input\")\n fourthPathChoice = input(\"1, 2\\n\")\n\n if fourthPathChoice == \"1\":\n print(\"You collected courage\")\n elif fourthPathChoice == \"2\":\n warriorPath1_1_1_2()\n break","def input_menu_choice():\r\n choice = str(input(\"Which option would you like to perform? [1 to 4] - \")).strip()\r\n return choice","def warriorPath1_1():\n with open('stories/warrior/warrior_path1_1.txt') as f:\n path1_1 = f.read()\n print(path1_1.format(NAME))\n while True:\n print(\"1. Attack the ogre\")\n print(\"2. Sneak around the ogre\")\n thirdPathChoice = input(\"1, 2\\n\")\n # Input validation\n while thirdPathChoice != \"1\" and thirdPathChoice != \"2\":\n print(\"Invalid input\")\n thirdPathChoice = input(\"1, 2\\n\")\n\n if thirdPathChoice == \"1\":\n warriorBattle()\n break\n elif thirdPathChoice == \"2\":\n warriorPath1_1_2()","def ask_path(prompt, default=None):\n response = simple_response(prompt, default)\n if os.path.exists(response):\n return response\n else:\n print('That path does not exist. Try again.')\n return ask_path(prompt, default)","def warriorPath0():\n pathChoice = input(\"1\\n\")\n # Input validation\n while pathChoice != \"1\":\n print(\"Invalid input\")\n pathChoice = input(\"1\\n\")\n\n if pathChoice == \"1\":\n warriorPath1()","def dmenu_input(scheme):\n choices = []\n for basedir, dirs , files in os.walk(scheme.prefix, followlinks=True):\n dirs.sort()\n files.sort()\n\n dirsubpath = basedir[len(scheme.prefix):].lstrip('/')\n for f in files:\n if f.endswith(scheme.suffix):\n full_path = os.path.join(dirsubpath, f.replace(scheme.suffix, '', -1))\n choices += [full_path]\n\n args = [\"-fn\", scheme.font, \\\n \"-nb\", scheme.nb, \\\n \"-nf\", scheme.nf, \\\n \"-sb\", scheme.sb, \\\n \"-sf\", scheme.sf, \\\n \"-i\" ]\n dmenu = subprocess.Popen(['dmenu'] + args,\n stdin=subprocess.PIPE,\n stderr=subprocess.PIPE,\n stdout=subprocess.PIPE)\n\n choice_lines = '\\n'.join(map(str, choices))\n choice, errors = dmenu.communicate(choice_lines.encode('utf-8'))\n\n if dmenu.returncode not in [0, 1] \\\n or (dmenu.returncode == 1 and len(errors) != 0):\n print(\"'{} {}' returned {} and error:\\n{}\"\n .format(['dmenu'], ' '.join(args), dmenu.returncode,\n errors.decode('utf-8')))\n sys.exit(1)\n\n choice = choice.decode('utf-8').rstrip()\n\n return (scheme.prefix + \"/\" + choice + scheme.suffix) if choice in choices else sys.exit(1)","def InputMenuChoice():\r\n choice = str(input(\"Which option would you like to perform? [1 to 4] - \")).strip()\r\n print() # Add an extra line for looks\r\n return choice","def choose_file(fname=None, env=None, choices=[]):\n if fname:\n fname = os.path.expanduser(fname)\n if os.path.exists(fname):\n return fname\n else:\n raise LookupError(f'No such file {fname}')\n elif env and env in os.environ:\n fname = os.path.expanduser(os.environ[env])\n if os.path.exists(fname):\n return fname\n else:\n raise LookupError(f'No such file {env} = {fname}')\n else:\n ch = []\n for c in choices:\n fname = os.path.expanduser(str(c))\n if os.path.exists(fname):\n return fname\n else:\n ch.append(fname)\n raise LookupError('File not found (tried {}{})'.format(\n env + (', ' if choices else '') if env else '', ', '.join(ch)))","def input_file_chooser(self):\n filename = tk.filedialog.askopenfilename()\n self._input_path_var.set(filename)","def GetInputPath(self):\n self.inputDir = raw_input(\"Where should files be read from? This can be a file or a folder of files\\n\\r>>> \")\n if os.path.isabs(self.inputDir):\n if os.path.isdir(self.inputDir):\n self.isFolder = True\n self.inputDirs = os.listdir(self.inputDir)\n elif os.path.isfile(self.inputDir):\n self.isFolder = False\n self.inputDirs = [self.inputDir]\n else:\n print \"That path does not exist. Try again\"\n self.GetInputPath()\n else:\n print \"that was not an excepted path name. Try again.\"\n self.GetInputPath()","def process_menu_page(self):\r\n self.print_options(self.menu,1)\r\n\r\n \"\"\"\r\n Asks for user input. Then redirects to the appropriate function.\r\n \"\"\"\r\n n = (input(\"What would you like to do? Please input the correpsonding integer:\"))\r\n\r\n if n == str(1):\r\n self.file_import()\r\n elif n == str(2):\r\n self.view_data()\r\n elif n == str(3):\r\n self.analysis()\r\n elif n == str(4):\r\n self.save()\r\n elif n == str('q'):\r\n quit()\r\n else:\r\n raise InputError(\"Please input a valid digit or 'q'\")","def mainMenuChoice():\r\n print(\"What would you like to do?\")\r\n print(\" n) Add a class\")\r\n print(\" d) Delete a class\")\r\n print(\" e) Edit a class\")\r\n print(\" s) Show ongoing list of classes\")\r\n print(\" p) Print Schedule to Terminal\")\r\n print(\" g) Generate schedule in csv and print to Terminal\")\r\n print(\" q) Save and Exit program\\n\")\r\n \r\n choice = input(\"Input choice here: \")\r\n \r\n if choice.lower() in [\"n\",\"d\",\"e\",\"s\",\"g\",\"q\", \"p\"]:\r\n return choice\r\n else:\r\n print(\"\\nPlease enter a valid menu choice\")\r\n return None","def userSpecify():\n valid = False\n while valid != True:\n userPath = raw_input(\"\\nPlease specify directory path or press Enter key for the current directory: \").strip()\n if userPath == \"\":\n path = \".\"\n else:\n path = userPath\n\n if os.path.exists(path):\n print(\"Path has been validated\")\n valid = True\n else:\n print(\"Invalid File Path, File Doesn't Exist! Please try again.\")\n continue\n return path","def ask_path():\n\n file_opt = options = {}\n options['initialdir'] = 'User\\\\'\n options['parent'] = root\n options['title'] = 'Choose directory'\n\n # get pathname\n pathname = tk.filedialog.askdirectory(**file_opt)\n\n if pathname:\n Data.out_dir = pathname\n path_var.set(pathname)","def _input_path() -> str:\n path_string = input('Path:').strip()\n return path_string","def filepicker(dir=os.curdir):\n choices = {}\n files = os.listdir(dir)\n files = sorted(\n [f for f in files if os.path.isfile(f) and '.csv' in f[-4:]])\n\n # Print the filenames with corresponding integers\n for index, filename in enumerate(files, 1):\n choices[index] = filename\n print(\"[{}] {}\".format(index, filename))\n\n choice = int(input(\"\\n>\").strip()) # Prompt user for choice\n print(\"-\" * 20, \"\\n\")\n if dir == os.curdir:\n return choices[choice]\n else:\n return dir + choices[choice]","def choose_click(self):\n choice = filedialog.askopenfilename(title='Alege baza de date', filetypes=[('Bază de date', '*.db')])\n if not choice:\n return\n\n self.path.set(choice)","def prompt(text, choices):\n text += \" [\" + \"/\".join(choices) + \"] \"\n while True:\n inp = input(text)\n if inp in choices:\n return inp","def askFilename():\n# print(\"\\nDo you have the file already?\"+\n# \"\\nYes - proceed\\t\\t No - go back to main menu\")\n# choice = input(\"(Y/N) \")\n# if choice.upper() == \"N\":\n# filename = None\n# elif choice.upper() == \"Y\": \n print(\"\\nInsert file name (without the filetype)\")\n print(\"(PRESS CTRL+C IF THERE IS NO FILE YET!!)\")\n fileOpt = input(\"or press enter if saved on default name: \") \n if fileOpt != \"\":\n filename = fileOpt+\".txt\"\n else:\n print(\"\\n\\nFinding file...\")\n print(\"\\n\\nWhich party is it for?\")\n print(\"A. Labor\\t\\t B. Liberal\")\n partyOpt = input(\"Selected party is (A/B): \")\n list1 = [\"A\", \"B\"]\n while partyOpt.upper() not in list1:\n partyOpt = input(\"Selected party is (A/B): \")\n marginOpt = input(\"\\nWhat was the margin used? (enter as int) \")\n if partyOpt.upper() == \"A\":\n filename = \"LaborParty_MarginalSeatList\"+str(marginOpt)+\"%.txt\"\n elif partyOpt.upper() == \"B\":\n filename = \"LiberalParty_MarginalSeatList\"+str(marginOpt)+\"%.txt\"\n return filename","def user_choice():\n\n OPTIONS = \"\"\"\n a) See ratings\n b) Add rating\n c) Quit\n \"\"\"\n\n while True:\n print OPTIONS\n user_choice = raw_input(\"What would you like to do?: \")\n\n if user_choice == \"a\":\n restaurant_rating(filename)\n elif user_choice == \"b\":\n user_input()\n elif user_choice == \"c\":\n print \"Good-bye!\"\n break\n else:\n print \"Invalid input\"","def choose(fdin, fdout, prompt, map_choices):\n cols = get_terminal_width(fdin)\n line = prompt\n print_line_ellipsized(fdout, cols, line)\n while True:\n char = read_one_character(fdin)\n if char in map_choices:\n return map_choices[char]","def ask_input(task):\n\n folder_found = False\n folder = \"\"\n ped_name = \"\"\n # Accepted undo operations\n _undo_operation = [\n 'Q', 'QUIT',\n 'B', 'BACK',\n 'U', 'UNDO'\n ]\n\n # Request for the data folder and check of its existence (if undo operation, return to the menu)\n while not folder_found:\n folder = input(\"Insert the folder path containing the PED you want to analyze: \")\n if folder.upper() in _undo_operation:\n return None\n if not os.path.isdir(folder):\n print('WARNING : You must provide an existing data location\\n')\n else:\n folder_found = True\n\n exit_menu = False\n while not exit_menu:\n\n # Extract PED ID of files contained in the folder: if no one is present, return to the menu\n ped_names = extract_names(folder, task=task)\n if len(ped_names) == 0:\n print('WARNING : Folder not containing PED files!')\n return None\n\n # Request for the PED to be analyzed showing the ones present in the folder\n print('')\n print('Which PED do you want to analyze: ')\n for i, names in enumerate(ped_names):\n print('\\t{} - {}'.format(i, names))\n\n ped_name = input('\\nYour choice: ')\n\n # Check of the choice\n if ped_name.upper() in _undo_operation:\n return None\n else:\n exit_menu, ped_name = check_input(ped_name, ped_names)\n\n return [folder, ped_name]","def select_path(self):\r\n pass","def choose(self, choice):\n if self.available(choice):\n self.select(choice)","def handle_select(self):\n #self.selected = input('>> ')\n self.selected = '0'\n if self.selected in ['Q', 'q']:\n sys.exit(1)\n elif self.selected in ['B', 'b']:\n self.back_to_menu = True\n return True\n elif is_num(self.selected):\n if 0 <= int(self.selected) <= len(self.hrefs) - 1:\n self.back_to_menu = False\n return True\n else:\n print(Colors.FAIL +\n 'Wrong index. ' +\n 'Please select an appropiate one or other option.' +\n Colors.ENDC)\n return False\n else:\n print(Colors.FAIL +\n 'Invalid input. ' +\n 'Please select an appropiate one or other option.' +\n Colors.ENDC)\n return False","def get_user_choice():\n user_input = input('Your choice: ')\n return user_input","def ask_path():\n\n file_opt = options = {}\n options['initialdir'] = 'User\\\\'\n options['parent'] = root\n options['title'] = 'Choose directory'\n\n # get path name\n pathname = tk.filedialog.asksaveasfilename(**file_opt)\n\n if pathname:\n Data.out_dir = pathname\n path_var.set(pathname)","def ask_path():\n\n file_opt = options = {}\n options['initialdir'] = 'User\\\\'\n options['parent'] = root\n options['title'] = 'Choose directory'\n\n # get path name\n pathname = tk.filedialog.asksaveasfilename(**file_opt)\n\n if pathname:\n Data.out_dir = pathname\n path_var.set(pathname)","def switch(self, an_input: str):\n\n # Empty command\n if not an_input:\n print(\"\")\n return None\n\n (known_args, other_args) = self.res_parser.parse_known_args(an_input.split())\n\n # Help menu again\n if known_args.cmd == \"?\":\n self.print_help()\n return None\n\n # Clear screen\n if known_args.cmd == \"cls\":\n os.system(\"cls||clear\")\n return None\n\n if other_args:\n print(f\"The following args were unexpected: {other_args}\")\n\n return getattr(\n self, \"call_\" + known_args.cmd, lambda: \"Command not recognized!\"\n )(None)","def main():\n switch_dict = {\"1\": thanks, \"2\": run_report, \"3\": create_thank_you_all, \"4\": exit_program}\n while True:\n response = input(menu)\n if response in switch_dict:\n switch_dict[response]()\n else:\n print(\"Not a valid option!\")","def _selectInput(self):\n\n (my_file, my_path) = misc.get_file(FilterSpec='*.wav', \n DialogTitle='Select sound-input:', \n DefaultName='')\n if my_path == 0:\n print('No file selected')\n return 0\n else:\n full_in_file = os.path.join(my_path, my_file)\n print('Selection: ' + full_in_file)\n return full_in_file","def browse_input(self):\n path = getAFolder()\n if len(path) > 0:\n self.in_directory.setText(path)\n self.out_directory.setText(join(path, 'merged_results'))\n self.preprocessfolder()","def menu():\n print(\"Choose an option\")\n print(\"(L)ist Friends\")\n print(\"(A)dd Friend\")\n print(\"(C)lear List\")\n print(\"(Q)uit\")\n while True:\n choice = input(\"Now choose: \").lower().strip()\n if choice in 'lacq':\n return choice\n print(\"Invalid choice.\")","def recipe_printer():\n\n path = os.curdir\n recipe = raw_input(\"What is the name of the recipe you want to view (don't use capital letters)? \")\n recipe += '.txt'\n if recipe in path:\n output = open(recipe)\n print output.read()\n output.close()\n else:\n print \"recipe was not found, please check your spelling.\"\n pass","def choose_file(self):\n self.choice = self.client.choose_file()\n\n if self.choice.drive == 'document':\n from docsparser import DocsParser\n self.parser = DocsParser(self.client, self.choice)\n else:\n raise NotImplementedError('{} service not implemented'.format(self.choice.drive))\n\n return self.choice","def get_choice(self):\n\n self.choice = int(input(\n \"\\nEntrez le chiffre correspondant à votre choix puis\"\n \"pressez sur ENTER : \"))\n return self.choice\n self.dispatch()","def browse(self):\n\n self.filepath.set(fd.askopenfilename(initialdir=self._initaldir,\n filetypes=self._filetypes))","def man_dir():\n\n print \"\\n\" + \"-\" * 8 + \"Select Direction\" + \"-\" * 8\n print \"1. Up\"\n print \"2. Down\"\n print \"3. Left\"\n print \"4. Right\"\n choice = valid(\"\\nSelect direction: \", 1, 4)\n\n if choice == 1:\n direct = \"U\"\n elif choice == 2:\n direct = \"D\"\n elif choice == 3:\n direct = \"L\"\n elif choice == 4:\n direct = \"R\"\n return direct","def choose_directory():\n \n directory = askdirectory()\n chdir(directory)","def input_user_choice_import(self):\r\n try:\r\n user_choice = input(\"Continuer l'importation? Y/N: \")\r\n if user_choice.lower() == 'y' or user_choice.lower() == 'n':\r\n return user_choice\r\n\r\n except ValueError:\r\n print(\"Veuillez choisir Y/N\")\r\n return self.input_user_choice_import()","def load(file_choice = file):\n\t\tif file_choice!=file:\n\t\t\tfile = file_choice\n\n\t\tpass","def choose(bot, trigger):\n if not trigger.group(2):\n return bot.reply('I\\'d choose an option, but you didn\\'t give me any.')\n choices = re.split('[\\|\\\\\\\\\\/]', trigger.group(2))\n pick = random.choice(choices)\n return bot.reply('Your options: %s. My choice: %s' % (', '.join(choices), pick))","def choose_story():\n madLibQ = input(\n \"Now there are two mad lib stories you can journey through, \"\n \"which story would you like to choose? 1 or 2?: \")\n # Mad Lib Story #1\n if madLibQ == \"1\":\n madlib1()\n # Mad Lib Story #2\n elif madLibQ == \"2\":\n madlib2()\n else:\n print(\"\")\n print(\"Invalid entry. Please try again.\")\n print(\"\")\n choose_story()","def file_path():\n file_name = input(\"Enter the file name:\")\n return file_name","def player_choice(text):\n try:\n action_choice = input(text)\n return action_choice.lower()\n except NameError:\n print(\"Invalid input. Please try again.\")","def pathfinder(Input):\n while True:\n if Input[-4::] == '.csv':\n return Input\n else:\n Input = input('Please enter a valid csv file: ')","def choose_query(screening_log_path: str):\n while True:\n # Ask for what the user would like to do\n print(\"1. Basic Screening Log Stats\")\n print(\"2. Get basic stats between two dates\")\n print(\"3. Get basic stats by time of day\")\n choice = input(\"What actions would you like to take, q to quit \")\n\n choices = {'1': get_screening_log_basic_stats,\n '2': get_screening_log_stats_by_date,\n '3': get_screening_log_stats_by_time,\n }\n\n if choice is not None and choice.strip() and choices.get(choice) is not None:\n choices[choice](screening_log_path)\n\n elif choice is not None and choice.strip() and choice.lower() == 'q':\n break\n # Bad Entry\n else:\n print(\"Please enter a valid choice\")","def handle_selection_eng(self):\n choice = self.get_input()\n if choice == '1':\n self.login_menu()\n elif choice == '2':\n self.authenticate_qr()\n elif choice == '3':\n self.authenticate_bluetooth()\n elif choice == '4':\n self.is_user = True\n self.display_main()","def menu():\r\n cont = False\r\n while cont == False:\r\n choice = input(\"Enter a letter to choose an option:\\n\" +\r\n \"e - Enter preferences\\nr - Get recommendations\\n\" +\r\n \"p - Show most popular artists\\nh - How popular is the most popular\\n\" +\r\n \"m - Which user has the most likes\\nq - Save and quit\\n\")\r\n if isinstance(choice, str):\r\n cont = True\r\n else:\r\n print(\"please enter one of the choices above\")\r\n return choice","def get_file():\n # Main Loop\n while True:\n filename = input(\"Please enter the name of the file you want to work on: \")\n # Check if file exists...\n if path.exists(filename):\n print(\"File sucessfully retrieved. Returning to previous menu...\")\n print()\n return filename\n \n print(\"That file does not exist in your current directroy. Try again.\")\n print()","def main_menu(): \r\n \r\n print(\"Please enter in the major for the class you need to study for: \")\r\n print(\"1. for Electrical Engineering\")\r\n print(\"2. for Bioengineering\")\r\n print(\"3. for Chemcial Engineering\")\r\n print(\"4. for Mechanical Engineering\")\r\n print(\"5. for Civil Engineering\")\r\n print(\"6. for Biology\")\r\n print(\"7. for Data Analytics\")\r\n print(\"8. for Chemistry\")\r\n choice = input()\r\n return choice","def get_choice():\n choice = input(\"Would you like to login/register: \")\n return choice","def switch(self, an_input: str):\n\n # Empty command\n if not an_input:\n print(\"\")\n return None\n\n (known_args, other_args) = self.fx_parser.parse_known_args(an_input.split())\n\n # Help menu again\n if known_args.cmd == \"?\":\n self.print_help()\n return None\n\n # Clear screen\n if known_args.cmd == \"cls\":\n system_clear()\n return None\n\n return getattr(\n self, \"call_\" + known_args.cmd, lambda: \"command not recognized!\"\n )(other_args)","def _take_option(self, options, print_out):\n user_choice = input(\"Please, choose one of the follewing options: \\n \" + print_out \n + \"\\n Your choice: \" )\n try:\n user_option = options[int(user_choice)]\n except KeyError:\n print(\"Please enter a vaild number\")\n self._take_option(options, print_out)\n \n except ValueError:\n print(\"Please a enter vaild number, not a string or some signs\")\n self._take_option(options, print_out)\n else:\n return user_option()","def get_valid_path(file_path: Path, prompt_title: str=\"PATH TO FILE\") -> Path:\n\n print(f\"{Color.EMPHASIS}{prompt_title}{Color.END}\")\n while True:\n if file_path.exists() and file_path.is_file():\n return file_path\n else:\n file_path = Path(input(f\"{Color.INFORMATION}Enter the file's path: {Color.END}\"))","def pick_place(choices_arg, question='Where to next?',inv=True):\r\n \r\n choices_alt = []\r\n \r\n if isinstance(choices_arg,list):\r\n choices = list(choices_arg)\r\n if inv:\r\n choices += ['inventory','map']\r\n \r\n elif isinstance(choices_arg,tuple):\r\n choices = choices_arg[0]\r\n choices_alt = choices_arg[1]\r\n if inv:\r\n choices += ['inventory','map']\r\n choices_alt += ['inventory','map']\r\n\r\n staying = True\r\n \r\n while staying:\r\n\r\n print question + '\\n'\r\n\r\n if choices_alt:\r\n for index in range(len(choices_alt)): #print alternate choices in menu form\r\n if str(choices[index]) == 'inventory':\r\n print\r\n print(str(index+1) + ': ' + str(choices_alt[index]))\r\n\r\n else:\r\n for index in range(len(choices)): #print choices in menu form\r\n if str(choices[index]) == 'inventory':\r\n print\r\n print(str(index+1) + ': ' + str(choices[index]))\r\n\r\n print('') #get some blank line in here yo\r\n chosen = raw_input('').lower()\r\n \r\n try:\r\n final = ''\r\n for index in range(len(choices)): #check if they typed a number\r\n item = choices[index]\r\n if index == int(chosen)-1:\r\n final = item\r\n staying = False\r\n if final == '':\r\n print 'Nice Try.\\n' #if they type a number not in range\r\n question = 'Try again, foo.'\r\n except:\r\n final = ''\r\n if choices_alt:\r\n for index in range(len(choices_alt)): #check if they typed letters\r\n item = choices_alt[index]\r\n if chosen == str(item).lower():\r\n final = choices[index]\r\n staying = False\r\n\r\n else:\r\n for index in range(len(choices)): #check if they typed letters\r\n item = choices[index]\r\n if chosen == str(item).lower():\r\n final = item\r\n staying = False\r\n if final == '':\r\n print 'Nice Try.\\n' #if they misspelled\r\n question = 'Try again, foo.'\r\n\r\n if final == 'map':\r\n inspect_map()\r\n question = 'Where to?'\r\n staying = True\r\n if final == 'inventory':\r\n inspect_inventory()\r\n question = 'Where to?'\r\n staying = True\r\n\r\n return final","def choice():\n choice = input(\"press e to encode press d to decode or press q to quit:\")\n if choice == \"e\":\n return \"e\"\n\n elif choice == \"d\":\n return \"d\"\n else:\n print(\"Okay bye\")","def handle_selection_main(self):\n choice = self.get_input()\n if choice == '1':\n self.display_cust()\n elif choice == '2':\n self.is_user = False\n self.display_eng()","def menu() -> str:\r\n user_choice = \"\"\r\n while user_choice not in [\"1\", \"2\", \"3\"]:\r\n user_choice = input(\"What do you want to do? \\n\"\r\n \"Enter 1 to search \\n\"\r\n \"Enter 2 to move a book \\n\"\r\n \"Enter 3 to save and quit\")\r\n\r\n if user_choice == \"1\":\r\n return \"search\"\r\n elif user_choice == \"2\":\r\n return \"move\"\r\n elif user_choice == \"3\":\r\n return \"quit\"\r\n else:\r\n print(\"Invalid input, try again\")","def menu_choice():\r\n choice = ' '\r\n while choice not in ['l', 'a', 'i', 'd', 's', 'x']:\r\n choice = input('Which operation would you like to perform? [l, a, i, d, s or x]: ').lower().strip()\r\n print() # Add extra space for layout\r\n return choice","def select_dir(self):\n prev_val = self.var_path.get()\n if self.conf_dir == \"dir_app\" or self.conf_dir == \"urls\":\n dir_ = fd.askopenfilename(parent=self.parentframe,\n initialdir=Path.home()) or prev_val\n else:\n dir_ = fd.askdirectory(parent=self.parentframe,\n initialdir=Path.home()) or prev_val\n\n self.var_path.set(value=dir_)\n if dir_ != prev_val:\n conf[self.conf_dir] = dir_\n self.handle_modified()","def select_path(self, path):\n self.exit_manager()\n\n if path.endswith('.obj'):\n EVENTS['IS_OBJ'] = True\n EVENTS['EDITOR_SAVED'] = True\n\n EVENTS['CAN_WRITE'] = True\n EVENTS['FILE_PATH'] = path\n EVENTS['LOADED_FILE'] = True\n toast(f'{path} loaded successfully')\n EVENTS['IS_RAM_EMPTY'] = False\n update_indicators(self.main_window, EVENTS['LOADED_FILE'])","def askOption():\n while True:\n print(\"Do you want to (E)ncode or (D)ecode?\") \n choice = input(\">> \")\n \n if choice.lower() in ['d','e']:\n return choice","async def choose(self, ctx, *args):\n query = \" \".join(args)\n choices = query.split(\" or \")\n if len(choices) < 2:\n await ctx.send(\"Give me at least 2 options to choose from! (separate options with `or`)\")\n self.logger.warning(misolog.format_log(ctx, f\"1 option\"))\n return\n choice = rd.choice(choices).strip()\n await ctx.send(f\"I choose **{choice}**\")\n self.logger.info(misolog.format_log(ctx, f\"{choice}\"))","def menu(target=None, saveas=None, returnStr=False):\n stuff = dict(enumerate([file for file in os.listdir(os.path.join(currPath, \"h2comp\")) if file.endswith(\".py\")], 1))\n if target is None:\n print(\"what do u want?\")\n for k, v in stuff.items():\n print(f\"{k}:{v}\")\n target = \"\"\n while target not in stuff.keys():\n target = int(input(\"enter a valid key: \"))\n \n with open(currPath + f\"/h2comp/{stuff[target]}\") as f:\n if saveas is None:\n if returnStr:\n return f.read()\n else:\n print(f.read())\n else:\n with open(saveas, \"w\") as f2:\n f2.write(f.read())","def browse(self):\n\t\tos.system(\"clear\")\n\t\tself._show_menu()\n\t\twhile True:\n\t\t\tchoice = input(\"Enter the according number above:\")\n\n\t\t\tif choice == \"1\":\n\t\t\t\tself._show_all_goods()\n\t\t\telif choice == \"2\":\n\t\t\t\tself._show_cate()\n\t\t\telif choice == \"3\":\n\t\t\t\tself._show_brand()\n\t\t\telif choice == \"4\":\n\t\t\t\tself._order()\n\t\t\t\tos.system('clear')\n\t\t\telse:\n\t\t\t\tcontinue\n\t\t\tself._show_menu()","def execute_factory_menu(cls) -> LibraryItemFactory:\n print(\"Item Loader\")\n print(\"-----------\")\n print(\"What kind of items would you like to load?\")\n print(\"1. Manga\")\n print(\"2. Games\")\n print(\"3. Movies\")\n user_choice = int(input(\"Enter your choice (1-3):\"))\n factory = cls.factory_map[user_choice]\n path = input(\"Enter a path: \")\n return factory(path)","def selection_input(\n self,\n prompt,\n choices,\n default=None,\n error_message=\"Invalid Selection\",\n transform=None\n ):\n while True:\n result = self.text_input(prompt, default)\n\n if transform is not None and result is not None:\n result = transform(result)\n\n if result in choices:\n return result\n\n print()\n print(error_message)","def prompt_user():\n print('Please insert image direcory:')\n inpt = input('> ')\n return inpt","def select_program(self):\r\n\r\n path_data = self.json_data # Deserialize json\r\n print(' '+path_data['title'] + '\\n\\n ' + path_data['desc'] + '\\n\\n' +\r\n path_data['path']['desc']) # Print title\r\n for option in path_data['path']['options']: # Print list of functions\r\n print(str(option['num'])+'. '+option['desc'])\r\n scenario = input()\r\n if scenario == '0':\r\n self.install_vk_api_for_python()\r\n elif scenario == '1':\r\n self.vk_sign_in()\r\n self.download_pics_from_dialogs()\r\n elif scenario == '2':\r\n self.vk_sign_in()\r\n self.tag = input('По какому тегу будем искать людей? (0 для отмены)\\n')\r\n if self.tag != '0':\r\n self.get_users_pool()\r\n self.get_friends_numbers()\r\n else:\r\n self.tag = None\r\n elif scenario == '3':\r\n counter = self.count_ffn()\r\n self.check_for_build_plot(counter)\r\n elif scenario == '4':\r\n self.vk_token_sing_in()\r\n self.find_most_popular()\r\n else:\r\n print('Ошибка ввода, попробуйте еще раз')\r\n time.sleep(0.5)\r\n self.select_program()\r\n print('Возвращаемся в главное меню...')\r\n time.sleep(1)\r\n self.select_program()","def get_value(self):\r\n return input(\"Enter your choice :\")","def main_menu_selection():\n action = input('''\n Pleaes select one:\n\n a - Send a thank you\n b - Create a report\n c - Quit\n >''')\n\n return action.strip()","def menu():\r\n \r\n choice = int(input((\"1.BFS\\n2.DFS\\n3.BestFS\\n4.Beam Search\\n5.BBS\\n6.A*\\n7.Exit\\nChoose an option: \")))\r\n while choice < 1 or choice > 7:\r\n print(\"Choice is invalid! Try again\")\r\n choice = int(input((\"1.BFS\\n3.Beam Search\\n4.BBS\\n5.A*\\n6.Exit\\nChoose an option: \")))\r\n print(\"\")\r\n \r\n \r\n return choice","def home(logger):\n while True:\n choice = input(\n \"Please choose: \"\n \"(1) view items to deliver, \"\n \"(2) view_products, \"\n \"(3) add new products, \"\n \"(4) update profile, \"\n \"(5) log out: \"\n )\n if choice not in ('1', '2', '3', '4', '5'):\n logger.log(\"Please pick a valid choice\")\n else:\n break\n logger.log(\n \"Please choose: \"\n \"(1) view items to deliver, \"\n \"(2) view_products, \"\n \"(3) add new products, \"\n \"(4) update profile, \"\n \"(5) log out: \"\n f\"{choice}\"\n )\n return choice","def menu_page():\n while True:\n try:\n print(\"Please choose one of the following options(1,2,3):\"\n \"\\n1. Send a Thank you. \\n2. Create a report\"\n \"\\n3. Send Letters to Everyone \\n4. Quit\")\n option = int(input('--->'))\n except ValueError:\n print(\"You have made an invalid choice, try again.\")\n page_break()\n return option","def select_file(category, performer=None):\n\n files = File.get_files_by_category(category, performer=performer)\n files_ = []\n for file in files:\n if isinstance(file, str):\n files_.append(PyInquirer.Separator())\n continue\n file.category = category\n file_ = {\n \"name\": file.get_title(),\n \"value\": file,\n }\n files_.append(file_)\n if len(files_) == 0:\n Settings.print(\"Missing Files\")\n return\n files_.append({\n \"name\": 'Back',\n \"value\": None,\n })\n question = {\n 'type': 'list',\n 'name': 'file',\n 'message': 'File Path:',\n 'choices': files_,\n # 'filter': lambda file: file.lower()\n }\n answer = PyInquirer.prompt(question)\n if not answer: return File.select_files()\n file = answer[\"file\"]\n if not Settings.confirm(file.get_path()): return None\n return file","def logic(ghost):\n print_pause(\"Where do you want to go?\\n\", 2)\n choice = input(\n \"Choose on of the following numbers:\\n1.\" +\n \"Railway station\\n\" +\n \"2. church street\\n3. fort\\n\").lower()\n if choice not in \"1\" and choice not in \"2\" and choice not in \"3\":\n print_pause(\"\\nSorry I don't understand!\", 0)\n print_pause(\"Please repeat the input!\\n\", 0)\n logic(ghost)\n choice1(choice, ghost)\n choice2(choice, ghost)\n choice3(choice, ghost)","def get_folder():\n return input(\"Folder: \")","def choose(inp):\n if not inp.text:\n return lex.input.missing\n options = [i.strip() for i in inp.text.split(',') if i.strip()]\n if not options:\n return lex.input.incorrect\n return random.choice(options)","def get_input(self):\n option = input(\"Enter the number of your choice: \")\n return option","def Infor_file():\n \n import os\n import sys\n pdbfile_list()\n\n file_list = pdbfile_list()\n\n items = os.listdir('/home/njesh/python-mini-project-JaneNjeri/PDB_files/')\n \n file_list = [name for name in items if name.endswith('.pdb')]\n\n for count, fileName in enumerate(file_list, 0):\n sys.stdout.write(\"[%d] %s\\n\\r\" % (count, fileName))\n\n choice = int(input(\"Select pdb file[0-%s]: \" % count))\n print(file_list[choice])\n \n return choice\n choice = infile\n Infor_menu()\n \n Mainmenu()","def menu_choice():\r\n choice = ' '\r\n while choice not in ['l', 'a', 'i', 'd', 's', 'x']:\r\n choice = input('Which operation wouild you like to perform? [l, a, i, d, s or x]: ').lower().strip()\r\n print() # Add extra space for layout\r\n return choice","def question():\n print('Enter 1 to search database by habitat with detailed information\\nEnter 2 to search database by coordinates \\nEnter 3 to search by habitat in csv file for a quick overview without detail')\n print('habitat search options so far:\\n Alpenvorland, Niederrheinisches Tiefland, Oberrheinisches Tiefland')\n src = int(input('Enter here:'))\n\n if src == 1:\n habitat = input('Enter name of habitat\\n')\n query = \"habitat = '\" + habitat + \"'\"\n search_db_via_query(query)\n elif src == 2:\n search_by_coordinates()\n elif src == 3:\n search_by_habitat()\n else:\n print('no data')","def prompt():\r\n inpt = -1\r\n valid_choices = ['1','2','3','4','5']\r\n while inpt not in valid_choices:\r\n inpt = input(\"\\nPlease select the number of the operation you wish \"\r\n \"to complete:\\n\" +\r\n \"1. Run file mover\\n2. Add directories\"\r\n \"\\n3. Remove directory\\n4. View saved directories\\n5. Quit\\n\").strip()\r\n if inpt not in valid_choices:\r\n print(\"\\n*** Invalid choice ***\")\r\n return inpt","def execute_factory_menu(cls):\n print(\"Item Loader\")\n print(\"-----------\")\n print(\"What kind of items would you like to load?\")\n print(\"1. Manga\")\n print(\"2. Games\")\n print(\"3. Movies\")\n user_choice = int(input(\"Enter your choice (1-3):\"))\n factory_type = cls.factory_map[user_choice]\n\n file_name = input(\"\\nEnter file name of the excel file to load from:\")\n return factory_type(file_name)","def inputChoice(self, question, options, hotkeys, default=None):\n options = options[:] # we don't want to edit the passed parameter\n for i in range(len(options)):\n option = options[i]\n hotkey = hotkeys[i]\n # try to mark a part of the option name as the hotkey\n m = re.search('[%s%s]' % (hotkey.lower(), hotkey.upper()), option)\n if hotkey == default:\n caseHotkey = hotkey.upper()\n else:\n caseHotkey = hotkey\n if m:\n pos = m.start()\n options[i] = '%s[%s]%s' % (option[:pos], caseHotkey,\n option[pos+1:])\n else:\n options[i] = '%s [%s]' % (option, caseHotkey)\n # loop until the user entered a valid choice\n while True:\n prompt = '%s (%s)' % (question, ', '.join(options))\n answer = self.input(prompt)\n if answer.lower() in hotkeys or answer.upper() in hotkeys:\n return answer\n elif default and answer=='': # empty string entered\n return default","def transfer_menu():\n print(\"What type of transfer do you want to use?\")\n for key in sorted(TRANSFER_MENU_SELECTIONS):\n print(\"[%s] %s\" % (key, TRANSFER_MENU_SELECTIONS[key]))\n choice = raw_input(\"> \")\n while choice not in list(TRANSFER_MENU_SELECTIONS.keys()):\n choice = raw_input(\"> \")\n return choice","def select_input(cls):\n #Change current working directory to root sdk directory\n Utility.pushd(Settings.rootSdkPath)\n print('Would you like to insert release notes?')\n print('0) Cancel')\n print('1) Insert directly from command line')\n print('2) Insert from a file')\n\n cls.init()\n\n inputValue = 0\n inputNote = False\n try:\n try: input = raw_input\n except NameError: pass\n inputValue = input('Select option: ')\n inputValue = int(inputValue)\n except SyntaxError:\n inputValue = 0\n if inputValue is 0:\n cls.logger.warning('Failed to create a release note')\n return False\n elif inputValue is 1:\n inputNote = cls.cmd_note()\n elif inputValue is 2:\n inputNote = cls.select_file()\n if inputNote is not False:\n mode = 'r+' if os.path.exists(Settings.releaseNotePath) else 'w+'\n with open(Settings.releaseNotePath, mode) as release_notes:\n oldContent = release_notes.read()\n release_notes.seek(0, 0)\n release_notes.write(inputNote.rstrip('\\r\\n') + '\\n' + oldContent)\n cls.logger.info('Successfuly created release note')\n # return to the base directory\n Utility.popd()\n return inputNote","def switch(self, an_input: str):\n\n # Empty command\n if not an_input:\n print(\"\")\n return None\n\n (known_args, other_args) = self.etf_parser.parse_known_args(an_input.split())\n\n # Help menu again\n if known_args.cmd == \"?\":\n self.print_help()\n return None\n\n # Clear screen\n if known_args.cmd == \"cls\":\n os.system(\"cls||clear\")\n return None\n\n return getattr(\n self, \"call_\" + known_args.cmd, lambda: \"Command not recognized!\"\n )(other_args)","def ask_for_sync_path():\n\n # Enable auto-completion of path and cursor movement using the readline and glob modules\n def path_completer(text, state):\n if u\"~\" in text:\n text = text.replace(u\"~\", os.path.expanduser(u\"~\"))\n\n paths = glob.glob(u\"%s*\" % text)\n paths.append(False)\n\n return os.path.abspath(paths[state]) + u'/'\n\n if unix:\n readline.set_completer_delims(u' \\t\\n;')\n readline.parse_and_bind(u\"tab: complete\")\n readline.set_completer(path_completer)\n\n found = False\n # Keep asking until a valid path has been entered by the user\n while not found:\n sync_path = input(u\"\\nEnter a relative or absolute path to sync to (~/Desktop/Canvas etc.):\\n$ \")\n\n # Expand tilde if present in the sync_path\n if u\"~\" in sync_path:\n sync_path = sync_path.replace(u\"~\", os.path.expanduser(u\"~\"))\n sync_path = os.path.abspath(sync_path)\n\n if not os.path.exists(os.path.split(sync_path)[0]):\n print(u\"\\n[ERROR] Base path '%s' does not exist.\" % os.path.split(sync_path)[0])\n else:\n found = True\n\n if unix:\n # Disable path auto-completer\n readline.parse_and_bind(u'set disable-completion on')\n\n return sync_path","def get_filename_as_agrv_if_no_ask(prompt):\n Found = False\n ln = len(sys.argv)\n while not Found:\n if ln < 2:\n file = input( prompt)\n else:\n file = sys.argv[1]\n try:\n RFH = open(file)\n Found = True\n except FileNotFoundError:\n print(\"%%Error! File not found!\")\n ln = 1\n# break\n return RFH","def get_user_choice():\n while True:\n direction = input(\"Please enter a direction as displayed above(type quit to exit): \").strip().upper()\n possible_directions = [\"N\", \"S\", \"W\", \"E\", \"QUIT\"]\n if direction not in possible_directions:\n print(\"Please enter only directions N, S, W, or E\")\n else:\n if direction == \"QUIT\":\n return \"quit\"\n return direction","def display():\r\n name = input(\"Enter the filename:\\n\")\r\n if name==\"42.txt\":\r\n print(f42)\r\n elif name == \"1015.txt\":\r\n print(f1015)\r\n else:\r\n print(\"File not found\")","def do_select(self, line):\n # Available data sources\n options = \"-csv\", \"-db\"\n args = list (arg.lower () for arg in str (line).split ())\n\n try:\n # Check if the input data source is available in this program or not\n if args[0] not in options:\n raise ValueError (\"The data resource is not available.\")\n else:\n # Code for initialise CSV data source\n if args[0] == \"-csv\":\n try:\n if len (args) == 1:\n self._shw.select_source (args[0][1:], \"employeeinfo.csv\")\n View.warning (\n \"No CSV file path specified. A default file \\\"employeeinfo.csv\\\" will be used.\")\n elif len (args) == 2:\n self._shw.select_source (args[0][1:], args[1])\n elif len (args) == 3:\n if args[1] == \"-a\":\n self._shw.select_source (args[0][1:], args[2], True)\n except (CSVError, OSError) as e:\n View.error (e)\n except Exception as e:\n View.error (e)\n else:\n View.success (\"Data source CSV is selected.\")\n\n # Code for initialise database source\n elif args[0] == \"-db\":\n try:\n self._shw.select_source (args[0][1:])\n except (ConnectionError, TypeError) as e:\n View.error (e)\n except Exception as e:\n View.error (e)\n else:\n View.success (\"Data source Database is selected.\")\n\n # Code for initialise XXXX data source\n else:\n pass\n # Catch and display error message\n except ValueError as e:\n View.error (str (e) + \"\\n\")\n View.help_select ()\n except Exception as e:\n View.error (e)","def read_path():\n global path\n if len(sys.argv) >= 2:\n path = sys.argv[1]\n else:\n path = \"train\"","def select_file_upload_method():\n\n if not Settings.prompt(\"upload files\"): \n return \"unset\"\n Settings.print(\"Select an upload source\")\n sources = Settings.get_source_options()\n question = {\n 'type': 'list',\n 'name': 'upload',\n 'message': 'Upload:',\n 'choices': [src.title() for src in sources]\n }\n upload = PyInquirer.prompt(question)[\"upload\"]\n\n\n # everything after this part should be in another function\n # this should just return the string of the upload source\n\n\n if str(upload) == \"Local\":\n return File.select_files()\n elif str(upload) == \"Google\":\n return Google_File.select_files()\n # elif str(upload) == \"Dropbox\":\n # return Dropbox.select_files()\n elif str(upload) == \"Remote\":\n return Remote.select_files()\n return File.select_files()","def get_input(prompt, default=None, choices=None, option_value=None):\r\n if option_value is not None:\r\n return option_value\r\n \r\n choices = choices or []\r\n while 1:\r\n r = raw_input(prompt+' ').strip()\r\n if not r and default is not None:\r\n return default\r\n if choices:\r\n if r not in choices:\r\n r = None\r\n else:\r\n break\r\n else:\r\n break\r\n return r"],"string":"[\n \"def warriorPath1():\\n with open('stories/warrior/warrior_path1.txt') as f:\\n path1 = f.read()\\n print(path1.format(NAME))\\n while True:\\n print(\\\"What will you do?\\\")\\n print(\\\"1. Don't light the torch and keep walking\\\")\\n print(\\\"2. Light the torch with magic\\\")\\n secondPathChoice = input(\\\"1, 2\\\\n\\\")\\n # Input validation\\n while secondPathChoice != \\\"1\\\" and secondPathChoice != \\\"2\\\":\\n print(\\\"Invalid input\\\")\\n secondPathChoice = input(\\\"1, 2\\\\n\\\")\\n\\n if secondPathChoice == \\\"1\\\":\\n warriorPath1_1()\\n break\\n elif secondPathChoice == \\\"2\\\":\\n warriorPath1_2()\",\n \"def choose_file():\\n chdir(getcwd()+'/data/US')\\n f = []\\n for (dirpath, dirnames, filenames) in walk(getcwd()):\\n f.extend(filenames)\\n print('Which file do you want to work on?')\\n for i in f:\\n print(str(f.index(i)) + ' - ' + i)\\n while True:\\n try:\\n return f[int(input('Type its number: '))]\\n except ValueError or IndexError:\\n print('Invalid input.')\",\n \"def warriorPath1_1_1_2():\\n with open('stories/warrior/warrior_path1_1_1_2.txt') as f:\\n path1_1_1_2 = f.read()\\n print(path1_1_1_2.format(NAME))\\n print(\\\"1. Take the Caldun\\\")\\n print(\\\"2. Leave\\\")\\n fifthPathChoice = input(\\\"1, 2\\\\n\\\")\\n # Input validation\\n while fifthPathChoice != \\\"1\\\" and fifthPathChoice != \\\"2\\\":\\n print(\\\"Invalid input\\\")\\n fifthPathChoice = input(\\\"1, 2\\\\n\\\")\\n\\n if fifthPathChoice == \\\"1\\\":\\n # Function called from gmail_sheet.py\\n update_sheet_warrior_ending_1()\\n # Display story\\n with open('stories/warrior/warrior_end_1.txt') as f:\\n end1 = f.read()\\n print(end1.format(NAME))\\n elif fifthPathChoice == \\\"2\\\":\\n # Function called from gmail_sheet.py\\n update_sheet_warrior_ending_2()\\n # Display story\\n with open('stories/warrior/warrior_end_2.txt') as f:\\n end2 = f.read()\\n print(end2.format(NAME))\",\n \"def choose_file(self):\\n pass\",\n \"def warriorPath1_1_1():\\n with open('stories/warrior/warrior_path1_1_1.txt') as f:\\n path1_1_1 = f.read()\\n print(path1_1_1.format(NAME))\\n while True:\\n print(\\\"What will you do?\\\")\\n print(\\\"1. Collect courage\\\")\\n print(\\\"2. Jump down\\\")\\n fourthPathChoice = input(\\\"1, 2\\\\n\\\")\\n # Input validation\\n while fourthPathChoice != \\\"1\\\" and fourthPathChoice != \\\"2\\\":\\n print(\\\"Invalid input\\\")\\n fourthPathChoice = input(\\\"1, 2\\\\n\\\")\\n\\n if fourthPathChoice == \\\"1\\\":\\n print(\\\"You collected courage\\\")\\n elif fourthPathChoice == \\\"2\\\":\\n warriorPath1_1_1_2()\\n break\",\n \"def input_menu_choice():\\r\\n choice = str(input(\\\"Which option would you like to perform? [1 to 4] - \\\")).strip()\\r\\n return choice\",\n \"def warriorPath1_1():\\n with open('stories/warrior/warrior_path1_1.txt') as f:\\n path1_1 = f.read()\\n print(path1_1.format(NAME))\\n while True:\\n print(\\\"1. Attack the ogre\\\")\\n print(\\\"2. Sneak around the ogre\\\")\\n thirdPathChoice = input(\\\"1, 2\\\\n\\\")\\n # Input validation\\n while thirdPathChoice != \\\"1\\\" and thirdPathChoice != \\\"2\\\":\\n print(\\\"Invalid input\\\")\\n thirdPathChoice = input(\\\"1, 2\\\\n\\\")\\n\\n if thirdPathChoice == \\\"1\\\":\\n warriorBattle()\\n break\\n elif thirdPathChoice == \\\"2\\\":\\n warriorPath1_1_2()\",\n \"def ask_path(prompt, default=None):\\n response = simple_response(prompt, default)\\n if os.path.exists(response):\\n return response\\n else:\\n print('That path does not exist. Try again.')\\n return ask_path(prompt, default)\",\n \"def warriorPath0():\\n pathChoice = input(\\\"1\\\\n\\\")\\n # Input validation\\n while pathChoice != \\\"1\\\":\\n print(\\\"Invalid input\\\")\\n pathChoice = input(\\\"1\\\\n\\\")\\n\\n if pathChoice == \\\"1\\\":\\n warriorPath1()\",\n \"def dmenu_input(scheme):\\n choices = []\\n for basedir, dirs , files in os.walk(scheme.prefix, followlinks=True):\\n dirs.sort()\\n files.sort()\\n\\n dirsubpath = basedir[len(scheme.prefix):].lstrip('/')\\n for f in files:\\n if f.endswith(scheme.suffix):\\n full_path = os.path.join(dirsubpath, f.replace(scheme.suffix, '', -1))\\n choices += [full_path]\\n\\n args = [\\\"-fn\\\", scheme.font, \\\\\\n \\\"-nb\\\", scheme.nb, \\\\\\n \\\"-nf\\\", scheme.nf, \\\\\\n \\\"-sb\\\", scheme.sb, \\\\\\n \\\"-sf\\\", scheme.sf, \\\\\\n \\\"-i\\\" ]\\n dmenu = subprocess.Popen(['dmenu'] + args,\\n stdin=subprocess.PIPE,\\n stderr=subprocess.PIPE,\\n stdout=subprocess.PIPE)\\n\\n choice_lines = '\\\\n'.join(map(str, choices))\\n choice, errors = dmenu.communicate(choice_lines.encode('utf-8'))\\n\\n if dmenu.returncode not in [0, 1] \\\\\\n or (dmenu.returncode == 1 and len(errors) != 0):\\n print(\\\"'{} {}' returned {} and error:\\\\n{}\\\"\\n .format(['dmenu'], ' '.join(args), dmenu.returncode,\\n errors.decode('utf-8')))\\n sys.exit(1)\\n\\n choice = choice.decode('utf-8').rstrip()\\n\\n return (scheme.prefix + \\\"/\\\" + choice + scheme.suffix) if choice in choices else sys.exit(1)\",\n \"def InputMenuChoice():\\r\\n choice = str(input(\\\"Which option would you like to perform? [1 to 4] - \\\")).strip()\\r\\n print() # Add an extra line for looks\\r\\n return choice\",\n \"def choose_file(fname=None, env=None, choices=[]):\\n if fname:\\n fname = os.path.expanduser(fname)\\n if os.path.exists(fname):\\n return fname\\n else:\\n raise LookupError(f'No such file {fname}')\\n elif env and env in os.environ:\\n fname = os.path.expanduser(os.environ[env])\\n if os.path.exists(fname):\\n return fname\\n else:\\n raise LookupError(f'No such file {env} = {fname}')\\n else:\\n ch = []\\n for c in choices:\\n fname = os.path.expanduser(str(c))\\n if os.path.exists(fname):\\n return fname\\n else:\\n ch.append(fname)\\n raise LookupError('File not found (tried {}{})'.format(\\n env + (', ' if choices else '') if env else '', ', '.join(ch)))\",\n \"def input_file_chooser(self):\\n filename = tk.filedialog.askopenfilename()\\n self._input_path_var.set(filename)\",\n \"def GetInputPath(self):\\n self.inputDir = raw_input(\\\"Where should files be read from? This can be a file or a folder of files\\\\n\\\\r>>> \\\")\\n if os.path.isabs(self.inputDir):\\n if os.path.isdir(self.inputDir):\\n self.isFolder = True\\n self.inputDirs = os.listdir(self.inputDir)\\n elif os.path.isfile(self.inputDir):\\n self.isFolder = False\\n self.inputDirs = [self.inputDir]\\n else:\\n print \\\"That path does not exist. Try again\\\"\\n self.GetInputPath()\\n else:\\n print \\\"that was not an excepted path name. Try again.\\\"\\n self.GetInputPath()\",\n \"def process_menu_page(self):\\r\\n self.print_options(self.menu,1)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Asks for user input. Then redirects to the appropriate function.\\r\\n \\\"\\\"\\\"\\r\\n n = (input(\\\"What would you like to do? Please input the correpsonding integer:\\\"))\\r\\n\\r\\n if n == str(1):\\r\\n self.file_import()\\r\\n elif n == str(2):\\r\\n self.view_data()\\r\\n elif n == str(3):\\r\\n self.analysis()\\r\\n elif n == str(4):\\r\\n self.save()\\r\\n elif n == str('q'):\\r\\n quit()\\r\\n else:\\r\\n raise InputError(\\\"Please input a valid digit or 'q'\\\")\",\n \"def mainMenuChoice():\\r\\n print(\\\"What would you like to do?\\\")\\r\\n print(\\\" n) Add a class\\\")\\r\\n print(\\\" d) Delete a class\\\")\\r\\n print(\\\" e) Edit a class\\\")\\r\\n print(\\\" s) Show ongoing list of classes\\\")\\r\\n print(\\\" p) Print Schedule to Terminal\\\")\\r\\n print(\\\" g) Generate schedule in csv and print to Terminal\\\")\\r\\n print(\\\" q) Save and Exit program\\\\n\\\")\\r\\n \\r\\n choice = input(\\\"Input choice here: \\\")\\r\\n \\r\\n if choice.lower() in [\\\"n\\\",\\\"d\\\",\\\"e\\\",\\\"s\\\",\\\"g\\\",\\\"q\\\", \\\"p\\\"]:\\r\\n return choice\\r\\n else:\\r\\n print(\\\"\\\\nPlease enter a valid menu choice\\\")\\r\\n return None\",\n \"def userSpecify():\\n valid = False\\n while valid != True:\\n userPath = raw_input(\\\"\\\\nPlease specify directory path or press Enter key for the current directory: \\\").strip()\\n if userPath == \\\"\\\":\\n path = \\\".\\\"\\n else:\\n path = userPath\\n\\n if os.path.exists(path):\\n print(\\\"Path has been validated\\\")\\n valid = True\\n else:\\n print(\\\"Invalid File Path, File Doesn't Exist! Please try again.\\\")\\n continue\\n return path\",\n \"def ask_path():\\n\\n file_opt = options = {}\\n options['initialdir'] = 'User\\\\\\\\'\\n options['parent'] = root\\n options['title'] = 'Choose directory'\\n\\n # get pathname\\n pathname = tk.filedialog.askdirectory(**file_opt)\\n\\n if pathname:\\n Data.out_dir = pathname\\n path_var.set(pathname)\",\n \"def _input_path() -> str:\\n path_string = input('Path:').strip()\\n return path_string\",\n \"def filepicker(dir=os.curdir):\\n choices = {}\\n files = os.listdir(dir)\\n files = sorted(\\n [f for f in files if os.path.isfile(f) and '.csv' in f[-4:]])\\n\\n # Print the filenames with corresponding integers\\n for index, filename in enumerate(files, 1):\\n choices[index] = filename\\n print(\\\"[{}] {}\\\".format(index, filename))\\n\\n choice = int(input(\\\"\\\\n>\\\").strip()) # Prompt user for choice\\n print(\\\"-\\\" * 20, \\\"\\\\n\\\")\\n if dir == os.curdir:\\n return choices[choice]\\n else:\\n return dir + choices[choice]\",\n \"def choose_click(self):\\n choice = filedialog.askopenfilename(title='Alege baza de date', filetypes=[('Bază de date', '*.db')])\\n if not choice:\\n return\\n\\n self.path.set(choice)\",\n \"def prompt(text, choices):\\n text += \\\" [\\\" + \\\"/\\\".join(choices) + \\\"] \\\"\\n while True:\\n inp = input(text)\\n if inp in choices:\\n return inp\",\n \"def askFilename():\\n# print(\\\"\\\\nDo you have the file already?\\\"+\\n# \\\"\\\\nYes - proceed\\\\t\\\\t No - go back to main menu\\\")\\n# choice = input(\\\"(Y/N) \\\")\\n# if choice.upper() == \\\"N\\\":\\n# filename = None\\n# elif choice.upper() == \\\"Y\\\": \\n print(\\\"\\\\nInsert file name (without the filetype)\\\")\\n print(\\\"(PRESS CTRL+C IF THERE IS NO FILE YET!!)\\\")\\n fileOpt = input(\\\"or press enter if saved on default name: \\\") \\n if fileOpt != \\\"\\\":\\n filename = fileOpt+\\\".txt\\\"\\n else:\\n print(\\\"\\\\n\\\\nFinding file...\\\")\\n print(\\\"\\\\n\\\\nWhich party is it for?\\\")\\n print(\\\"A. Labor\\\\t\\\\t B. Liberal\\\")\\n partyOpt = input(\\\"Selected party is (A/B): \\\")\\n list1 = [\\\"A\\\", \\\"B\\\"]\\n while partyOpt.upper() not in list1:\\n partyOpt = input(\\\"Selected party is (A/B): \\\")\\n marginOpt = input(\\\"\\\\nWhat was the margin used? (enter as int) \\\")\\n if partyOpt.upper() == \\\"A\\\":\\n filename = \\\"LaborParty_MarginalSeatList\\\"+str(marginOpt)+\\\"%.txt\\\"\\n elif partyOpt.upper() == \\\"B\\\":\\n filename = \\\"LiberalParty_MarginalSeatList\\\"+str(marginOpt)+\\\"%.txt\\\"\\n return filename\",\n \"def user_choice():\\n\\n OPTIONS = \\\"\\\"\\\"\\n a) See ratings\\n b) Add rating\\n c) Quit\\n \\\"\\\"\\\"\\n\\n while True:\\n print OPTIONS\\n user_choice = raw_input(\\\"What would you like to do?: \\\")\\n\\n if user_choice == \\\"a\\\":\\n restaurant_rating(filename)\\n elif user_choice == \\\"b\\\":\\n user_input()\\n elif user_choice == \\\"c\\\":\\n print \\\"Good-bye!\\\"\\n break\\n else:\\n print \\\"Invalid input\\\"\",\n \"def choose(fdin, fdout, prompt, map_choices):\\n cols = get_terminal_width(fdin)\\n line = prompt\\n print_line_ellipsized(fdout, cols, line)\\n while True:\\n char = read_one_character(fdin)\\n if char in map_choices:\\n return map_choices[char]\",\n \"def ask_input(task):\\n\\n folder_found = False\\n folder = \\\"\\\"\\n ped_name = \\\"\\\"\\n # Accepted undo operations\\n _undo_operation = [\\n 'Q', 'QUIT',\\n 'B', 'BACK',\\n 'U', 'UNDO'\\n ]\\n\\n # Request for the data folder and check of its existence (if undo operation, return to the menu)\\n while not folder_found:\\n folder = input(\\\"Insert the folder path containing the PED you want to analyze: \\\")\\n if folder.upper() in _undo_operation:\\n return None\\n if not os.path.isdir(folder):\\n print('WARNING : You must provide an existing data location\\\\n')\\n else:\\n folder_found = True\\n\\n exit_menu = False\\n while not exit_menu:\\n\\n # Extract PED ID of files contained in the folder: if no one is present, return to the menu\\n ped_names = extract_names(folder, task=task)\\n if len(ped_names) == 0:\\n print('WARNING : Folder not containing PED files!')\\n return None\\n\\n # Request for the PED to be analyzed showing the ones present in the folder\\n print('')\\n print('Which PED do you want to analyze: ')\\n for i, names in enumerate(ped_names):\\n print('\\\\t{} - {}'.format(i, names))\\n\\n ped_name = input('\\\\nYour choice: ')\\n\\n # Check of the choice\\n if ped_name.upper() in _undo_operation:\\n return None\\n else:\\n exit_menu, ped_name = check_input(ped_name, ped_names)\\n\\n return [folder, ped_name]\",\n \"def select_path(self):\\r\\n pass\",\n \"def choose(self, choice):\\n if self.available(choice):\\n self.select(choice)\",\n \"def handle_select(self):\\n #self.selected = input('>> ')\\n self.selected = '0'\\n if self.selected in ['Q', 'q']:\\n sys.exit(1)\\n elif self.selected in ['B', 'b']:\\n self.back_to_menu = True\\n return True\\n elif is_num(self.selected):\\n if 0 <= int(self.selected) <= len(self.hrefs) - 1:\\n self.back_to_menu = False\\n return True\\n else:\\n print(Colors.FAIL +\\n 'Wrong index. ' +\\n 'Please select an appropiate one or other option.' +\\n Colors.ENDC)\\n return False\\n else:\\n print(Colors.FAIL +\\n 'Invalid input. ' +\\n 'Please select an appropiate one or other option.' +\\n Colors.ENDC)\\n return False\",\n \"def get_user_choice():\\n user_input = input('Your choice: ')\\n return user_input\",\n \"def ask_path():\\n\\n file_opt = options = {}\\n options['initialdir'] = 'User\\\\\\\\'\\n options['parent'] = root\\n options['title'] = 'Choose directory'\\n\\n # get path name\\n pathname = tk.filedialog.asksaveasfilename(**file_opt)\\n\\n if pathname:\\n Data.out_dir = pathname\\n path_var.set(pathname)\",\n \"def ask_path():\\n\\n file_opt = options = {}\\n options['initialdir'] = 'User\\\\\\\\'\\n options['parent'] = root\\n options['title'] = 'Choose directory'\\n\\n # get path name\\n pathname = tk.filedialog.asksaveasfilename(**file_opt)\\n\\n if pathname:\\n Data.out_dir = pathname\\n path_var.set(pathname)\",\n \"def switch(self, an_input: str):\\n\\n # Empty command\\n if not an_input:\\n print(\\\"\\\")\\n return None\\n\\n (known_args, other_args) = self.res_parser.parse_known_args(an_input.split())\\n\\n # Help menu again\\n if known_args.cmd == \\\"?\\\":\\n self.print_help()\\n return None\\n\\n # Clear screen\\n if known_args.cmd == \\\"cls\\\":\\n os.system(\\\"cls||clear\\\")\\n return None\\n\\n if other_args:\\n print(f\\\"The following args were unexpected: {other_args}\\\")\\n\\n return getattr(\\n self, \\\"call_\\\" + known_args.cmd, lambda: \\\"Command not recognized!\\\"\\n )(None)\",\n \"def main():\\n switch_dict = {\\\"1\\\": thanks, \\\"2\\\": run_report, \\\"3\\\": create_thank_you_all, \\\"4\\\": exit_program}\\n while True:\\n response = input(menu)\\n if response in switch_dict:\\n switch_dict[response]()\\n else:\\n print(\\\"Not a valid option!\\\")\",\n \"def _selectInput(self):\\n\\n (my_file, my_path) = misc.get_file(FilterSpec='*.wav', \\n DialogTitle='Select sound-input:', \\n DefaultName='')\\n if my_path == 0:\\n print('No file selected')\\n return 0\\n else:\\n full_in_file = os.path.join(my_path, my_file)\\n print('Selection: ' + full_in_file)\\n return full_in_file\",\n \"def browse_input(self):\\n path = getAFolder()\\n if len(path) > 0:\\n self.in_directory.setText(path)\\n self.out_directory.setText(join(path, 'merged_results'))\\n self.preprocessfolder()\",\n \"def menu():\\n print(\\\"Choose an option\\\")\\n print(\\\"(L)ist Friends\\\")\\n print(\\\"(A)dd Friend\\\")\\n print(\\\"(C)lear List\\\")\\n print(\\\"(Q)uit\\\")\\n while True:\\n choice = input(\\\"Now choose: \\\").lower().strip()\\n if choice in 'lacq':\\n return choice\\n print(\\\"Invalid choice.\\\")\",\n \"def recipe_printer():\\n\\n path = os.curdir\\n recipe = raw_input(\\\"What is the name of the recipe you want to view (don't use capital letters)? \\\")\\n recipe += '.txt'\\n if recipe in path:\\n output = open(recipe)\\n print output.read()\\n output.close()\\n else:\\n print \\\"recipe was not found, please check your spelling.\\\"\\n pass\",\n \"def choose_file(self):\\n self.choice = self.client.choose_file()\\n\\n if self.choice.drive == 'document':\\n from docsparser import DocsParser\\n self.parser = DocsParser(self.client, self.choice)\\n else:\\n raise NotImplementedError('{} service not implemented'.format(self.choice.drive))\\n\\n return self.choice\",\n \"def get_choice(self):\\n\\n self.choice = int(input(\\n \\\"\\\\nEntrez le chiffre correspondant à votre choix puis\\\"\\n \\\"pressez sur ENTER : \\\"))\\n return self.choice\\n self.dispatch()\",\n \"def browse(self):\\n\\n self.filepath.set(fd.askopenfilename(initialdir=self._initaldir,\\n filetypes=self._filetypes))\",\n \"def man_dir():\\n\\n print \\\"\\\\n\\\" + \\\"-\\\" * 8 + \\\"Select Direction\\\" + \\\"-\\\" * 8\\n print \\\"1. Up\\\"\\n print \\\"2. Down\\\"\\n print \\\"3. Left\\\"\\n print \\\"4. Right\\\"\\n choice = valid(\\\"\\\\nSelect direction: \\\", 1, 4)\\n\\n if choice == 1:\\n direct = \\\"U\\\"\\n elif choice == 2:\\n direct = \\\"D\\\"\\n elif choice == 3:\\n direct = \\\"L\\\"\\n elif choice == 4:\\n direct = \\\"R\\\"\\n return direct\",\n \"def choose_directory():\\n \\n directory = askdirectory()\\n chdir(directory)\",\n \"def input_user_choice_import(self):\\r\\n try:\\r\\n user_choice = input(\\\"Continuer l'importation? Y/N: \\\")\\r\\n if user_choice.lower() == 'y' or user_choice.lower() == 'n':\\r\\n return user_choice\\r\\n\\r\\n except ValueError:\\r\\n print(\\\"Veuillez choisir Y/N\\\")\\r\\n return self.input_user_choice_import()\",\n \"def load(file_choice = file):\\n\\t\\tif file_choice!=file:\\n\\t\\t\\tfile = file_choice\\n\\n\\t\\tpass\",\n \"def choose(bot, trigger):\\n if not trigger.group(2):\\n return bot.reply('I\\\\'d choose an option, but you didn\\\\'t give me any.')\\n choices = re.split('[\\\\|\\\\\\\\\\\\\\\\\\\\/]', trigger.group(2))\\n pick = random.choice(choices)\\n return bot.reply('Your options: %s. My choice: %s' % (', '.join(choices), pick))\",\n \"def choose_story():\\n madLibQ = input(\\n \\\"Now there are two mad lib stories you can journey through, \\\"\\n \\\"which story would you like to choose? 1 or 2?: \\\")\\n # Mad Lib Story #1\\n if madLibQ == \\\"1\\\":\\n madlib1()\\n # Mad Lib Story #2\\n elif madLibQ == \\\"2\\\":\\n madlib2()\\n else:\\n print(\\\"\\\")\\n print(\\\"Invalid entry. Please try again.\\\")\\n print(\\\"\\\")\\n choose_story()\",\n \"def file_path():\\n file_name = input(\\\"Enter the file name:\\\")\\n return file_name\",\n \"def player_choice(text):\\n try:\\n action_choice = input(text)\\n return action_choice.lower()\\n except NameError:\\n print(\\\"Invalid input. Please try again.\\\")\",\n \"def pathfinder(Input):\\n while True:\\n if Input[-4::] == '.csv':\\n return Input\\n else:\\n Input = input('Please enter a valid csv file: ')\",\n \"def choose_query(screening_log_path: str):\\n while True:\\n # Ask for what the user would like to do\\n print(\\\"1. Basic Screening Log Stats\\\")\\n print(\\\"2. Get basic stats between two dates\\\")\\n print(\\\"3. Get basic stats by time of day\\\")\\n choice = input(\\\"What actions would you like to take, q to quit \\\")\\n\\n choices = {'1': get_screening_log_basic_stats,\\n '2': get_screening_log_stats_by_date,\\n '3': get_screening_log_stats_by_time,\\n }\\n\\n if choice is not None and choice.strip() and choices.get(choice) is not None:\\n choices[choice](screening_log_path)\\n\\n elif choice is not None and choice.strip() and choice.lower() == 'q':\\n break\\n # Bad Entry\\n else:\\n print(\\\"Please enter a valid choice\\\")\",\n \"def handle_selection_eng(self):\\n choice = self.get_input()\\n if choice == '1':\\n self.login_menu()\\n elif choice == '2':\\n self.authenticate_qr()\\n elif choice == '3':\\n self.authenticate_bluetooth()\\n elif choice == '4':\\n self.is_user = True\\n self.display_main()\",\n \"def menu():\\r\\n cont = False\\r\\n while cont == False:\\r\\n choice = input(\\\"Enter a letter to choose an option:\\\\n\\\" +\\r\\n \\\"e - Enter preferences\\\\nr - Get recommendations\\\\n\\\" +\\r\\n \\\"p - Show most popular artists\\\\nh - How popular is the most popular\\\\n\\\" +\\r\\n \\\"m - Which user has the most likes\\\\nq - Save and quit\\\\n\\\")\\r\\n if isinstance(choice, str):\\r\\n cont = True\\r\\n else:\\r\\n print(\\\"please enter one of the choices above\\\")\\r\\n return choice\",\n \"def get_file():\\n # Main Loop\\n while True:\\n filename = input(\\\"Please enter the name of the file you want to work on: \\\")\\n # Check if file exists...\\n if path.exists(filename):\\n print(\\\"File sucessfully retrieved. Returning to previous menu...\\\")\\n print()\\n return filename\\n \\n print(\\\"That file does not exist in your current directroy. Try again.\\\")\\n print()\",\n \"def main_menu(): \\r\\n \\r\\n print(\\\"Please enter in the major for the class you need to study for: \\\")\\r\\n print(\\\"1. for Electrical Engineering\\\")\\r\\n print(\\\"2. for Bioengineering\\\")\\r\\n print(\\\"3. for Chemcial Engineering\\\")\\r\\n print(\\\"4. for Mechanical Engineering\\\")\\r\\n print(\\\"5. for Civil Engineering\\\")\\r\\n print(\\\"6. for Biology\\\")\\r\\n print(\\\"7. for Data Analytics\\\")\\r\\n print(\\\"8. for Chemistry\\\")\\r\\n choice = input()\\r\\n return choice\",\n \"def get_choice():\\n choice = input(\\\"Would you like to login/register: \\\")\\n return choice\",\n \"def switch(self, an_input: str):\\n\\n # Empty command\\n if not an_input:\\n print(\\\"\\\")\\n return None\\n\\n (known_args, other_args) = self.fx_parser.parse_known_args(an_input.split())\\n\\n # Help menu again\\n if known_args.cmd == \\\"?\\\":\\n self.print_help()\\n return None\\n\\n # Clear screen\\n if known_args.cmd == \\\"cls\\\":\\n system_clear()\\n return None\\n\\n return getattr(\\n self, \\\"call_\\\" + known_args.cmd, lambda: \\\"command not recognized!\\\"\\n )(other_args)\",\n \"def _take_option(self, options, print_out):\\n user_choice = input(\\\"Please, choose one of the follewing options: \\\\n \\\" + print_out \\n + \\\"\\\\n Your choice: \\\" )\\n try:\\n user_option = options[int(user_choice)]\\n except KeyError:\\n print(\\\"Please enter a vaild number\\\")\\n self._take_option(options, print_out)\\n \\n except ValueError:\\n print(\\\"Please a enter vaild number, not a string or some signs\\\")\\n self._take_option(options, print_out)\\n else:\\n return user_option()\",\n \"def get_valid_path(file_path: Path, prompt_title: str=\\\"PATH TO FILE\\\") -> Path:\\n\\n print(f\\\"{Color.EMPHASIS}{prompt_title}{Color.END}\\\")\\n while True:\\n if file_path.exists() and file_path.is_file():\\n return file_path\\n else:\\n file_path = Path(input(f\\\"{Color.INFORMATION}Enter the file's path: {Color.END}\\\"))\",\n \"def pick_place(choices_arg, question='Where to next?',inv=True):\\r\\n \\r\\n choices_alt = []\\r\\n \\r\\n if isinstance(choices_arg,list):\\r\\n choices = list(choices_arg)\\r\\n if inv:\\r\\n choices += ['inventory','map']\\r\\n \\r\\n elif isinstance(choices_arg,tuple):\\r\\n choices = choices_arg[0]\\r\\n choices_alt = choices_arg[1]\\r\\n if inv:\\r\\n choices += ['inventory','map']\\r\\n choices_alt += ['inventory','map']\\r\\n\\r\\n staying = True\\r\\n \\r\\n while staying:\\r\\n\\r\\n print question + '\\\\n'\\r\\n\\r\\n if choices_alt:\\r\\n for index in range(len(choices_alt)): #print alternate choices in menu form\\r\\n if str(choices[index]) == 'inventory':\\r\\n print\\r\\n print(str(index+1) + ': ' + str(choices_alt[index]))\\r\\n\\r\\n else:\\r\\n for index in range(len(choices)): #print choices in menu form\\r\\n if str(choices[index]) == 'inventory':\\r\\n print\\r\\n print(str(index+1) + ': ' + str(choices[index]))\\r\\n\\r\\n print('') #get some blank line in here yo\\r\\n chosen = raw_input('').lower()\\r\\n \\r\\n try:\\r\\n final = ''\\r\\n for index in range(len(choices)): #check if they typed a number\\r\\n item = choices[index]\\r\\n if index == int(chosen)-1:\\r\\n final = item\\r\\n staying = False\\r\\n if final == '':\\r\\n print 'Nice Try.\\\\n' #if they type a number not in range\\r\\n question = 'Try again, foo.'\\r\\n except:\\r\\n final = ''\\r\\n if choices_alt:\\r\\n for index in range(len(choices_alt)): #check if they typed letters\\r\\n item = choices_alt[index]\\r\\n if chosen == str(item).lower():\\r\\n final = choices[index]\\r\\n staying = False\\r\\n\\r\\n else:\\r\\n for index in range(len(choices)): #check if they typed letters\\r\\n item = choices[index]\\r\\n if chosen == str(item).lower():\\r\\n final = item\\r\\n staying = False\\r\\n if final == '':\\r\\n print 'Nice Try.\\\\n' #if they misspelled\\r\\n question = 'Try again, foo.'\\r\\n\\r\\n if final == 'map':\\r\\n inspect_map()\\r\\n question = 'Where to?'\\r\\n staying = True\\r\\n if final == 'inventory':\\r\\n inspect_inventory()\\r\\n question = 'Where to?'\\r\\n staying = True\\r\\n\\r\\n return final\",\n \"def choice():\\n choice = input(\\\"press e to encode press d to decode or press q to quit:\\\")\\n if choice == \\\"e\\\":\\n return \\\"e\\\"\\n\\n elif choice == \\\"d\\\":\\n return \\\"d\\\"\\n else:\\n print(\\\"Okay bye\\\")\",\n \"def handle_selection_main(self):\\n choice = self.get_input()\\n if choice == '1':\\n self.display_cust()\\n elif choice == '2':\\n self.is_user = False\\n self.display_eng()\",\n \"def menu() -> str:\\r\\n user_choice = \\\"\\\"\\r\\n while user_choice not in [\\\"1\\\", \\\"2\\\", \\\"3\\\"]:\\r\\n user_choice = input(\\\"What do you want to do? \\\\n\\\"\\r\\n \\\"Enter 1 to search \\\\n\\\"\\r\\n \\\"Enter 2 to move a book \\\\n\\\"\\r\\n \\\"Enter 3 to save and quit\\\")\\r\\n\\r\\n if user_choice == \\\"1\\\":\\r\\n return \\\"search\\\"\\r\\n elif user_choice == \\\"2\\\":\\r\\n return \\\"move\\\"\\r\\n elif user_choice == \\\"3\\\":\\r\\n return \\\"quit\\\"\\r\\n else:\\r\\n print(\\\"Invalid input, try again\\\")\",\n \"def menu_choice():\\r\\n choice = ' '\\r\\n while choice not in ['l', 'a', 'i', 'd', 's', 'x']:\\r\\n choice = input('Which operation would you like to perform? [l, a, i, d, s or x]: ').lower().strip()\\r\\n print() # Add extra space for layout\\r\\n return choice\",\n \"def select_dir(self):\\n prev_val = self.var_path.get()\\n if self.conf_dir == \\\"dir_app\\\" or self.conf_dir == \\\"urls\\\":\\n dir_ = fd.askopenfilename(parent=self.parentframe,\\n initialdir=Path.home()) or prev_val\\n else:\\n dir_ = fd.askdirectory(parent=self.parentframe,\\n initialdir=Path.home()) or prev_val\\n\\n self.var_path.set(value=dir_)\\n if dir_ != prev_val:\\n conf[self.conf_dir] = dir_\\n self.handle_modified()\",\n \"def select_path(self, path):\\n self.exit_manager()\\n\\n if path.endswith('.obj'):\\n EVENTS['IS_OBJ'] = True\\n EVENTS['EDITOR_SAVED'] = True\\n\\n EVENTS['CAN_WRITE'] = True\\n EVENTS['FILE_PATH'] = path\\n EVENTS['LOADED_FILE'] = True\\n toast(f'{path} loaded successfully')\\n EVENTS['IS_RAM_EMPTY'] = False\\n update_indicators(self.main_window, EVENTS['LOADED_FILE'])\",\n \"def askOption():\\n while True:\\n print(\\\"Do you want to (E)ncode or (D)ecode?\\\") \\n choice = input(\\\">> \\\")\\n \\n if choice.lower() in ['d','e']:\\n return choice\",\n \"async def choose(self, ctx, *args):\\n query = \\\" \\\".join(args)\\n choices = query.split(\\\" or \\\")\\n if len(choices) < 2:\\n await ctx.send(\\\"Give me at least 2 options to choose from! (separate options with `or`)\\\")\\n self.logger.warning(misolog.format_log(ctx, f\\\"1 option\\\"))\\n return\\n choice = rd.choice(choices).strip()\\n await ctx.send(f\\\"I choose **{choice}**\\\")\\n self.logger.info(misolog.format_log(ctx, f\\\"{choice}\\\"))\",\n \"def menu(target=None, saveas=None, returnStr=False):\\n stuff = dict(enumerate([file for file in os.listdir(os.path.join(currPath, \\\"h2comp\\\")) if file.endswith(\\\".py\\\")], 1))\\n if target is None:\\n print(\\\"what do u want?\\\")\\n for k, v in stuff.items():\\n print(f\\\"{k}:{v}\\\")\\n target = \\\"\\\"\\n while target not in stuff.keys():\\n target = int(input(\\\"enter a valid key: \\\"))\\n \\n with open(currPath + f\\\"/h2comp/{stuff[target]}\\\") as f:\\n if saveas is None:\\n if returnStr:\\n return f.read()\\n else:\\n print(f.read())\\n else:\\n with open(saveas, \\\"w\\\") as f2:\\n f2.write(f.read())\",\n \"def browse(self):\\n\\t\\tos.system(\\\"clear\\\")\\n\\t\\tself._show_menu()\\n\\t\\twhile True:\\n\\t\\t\\tchoice = input(\\\"Enter the according number above:\\\")\\n\\n\\t\\t\\tif choice == \\\"1\\\":\\n\\t\\t\\t\\tself._show_all_goods()\\n\\t\\t\\telif choice == \\\"2\\\":\\n\\t\\t\\t\\tself._show_cate()\\n\\t\\t\\telif choice == \\\"3\\\":\\n\\t\\t\\t\\tself._show_brand()\\n\\t\\t\\telif choice == \\\"4\\\":\\n\\t\\t\\t\\tself._order()\\n\\t\\t\\t\\tos.system('clear')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tself._show_menu()\",\n \"def execute_factory_menu(cls) -> LibraryItemFactory:\\n print(\\\"Item Loader\\\")\\n print(\\\"-----------\\\")\\n print(\\\"What kind of items would you like to load?\\\")\\n print(\\\"1. Manga\\\")\\n print(\\\"2. Games\\\")\\n print(\\\"3. Movies\\\")\\n user_choice = int(input(\\\"Enter your choice (1-3):\\\"))\\n factory = cls.factory_map[user_choice]\\n path = input(\\\"Enter a path: \\\")\\n return factory(path)\",\n \"def selection_input(\\n self,\\n prompt,\\n choices,\\n default=None,\\n error_message=\\\"Invalid Selection\\\",\\n transform=None\\n ):\\n while True:\\n result = self.text_input(prompt, default)\\n\\n if transform is not None and result is not None:\\n result = transform(result)\\n\\n if result in choices:\\n return result\\n\\n print()\\n print(error_message)\",\n \"def prompt_user():\\n print('Please insert image direcory:')\\n inpt = input('> ')\\n return inpt\",\n \"def select_program(self):\\r\\n\\r\\n path_data = self.json_data # Deserialize json\\r\\n print(' '+path_data['title'] + '\\\\n\\\\n ' + path_data['desc'] + '\\\\n\\\\n' +\\r\\n path_data['path']['desc']) # Print title\\r\\n for option in path_data['path']['options']: # Print list of functions\\r\\n print(str(option['num'])+'. '+option['desc'])\\r\\n scenario = input()\\r\\n if scenario == '0':\\r\\n self.install_vk_api_for_python()\\r\\n elif scenario == '1':\\r\\n self.vk_sign_in()\\r\\n self.download_pics_from_dialogs()\\r\\n elif scenario == '2':\\r\\n self.vk_sign_in()\\r\\n self.tag = input('По какому тегу будем искать людей? (0 для отмены)\\\\n')\\r\\n if self.tag != '0':\\r\\n self.get_users_pool()\\r\\n self.get_friends_numbers()\\r\\n else:\\r\\n self.tag = None\\r\\n elif scenario == '3':\\r\\n counter = self.count_ffn()\\r\\n self.check_for_build_plot(counter)\\r\\n elif scenario == '4':\\r\\n self.vk_token_sing_in()\\r\\n self.find_most_popular()\\r\\n else:\\r\\n print('Ошибка ввода, попробуйте еще раз')\\r\\n time.sleep(0.5)\\r\\n self.select_program()\\r\\n print('Возвращаемся в главное меню...')\\r\\n time.sleep(1)\\r\\n self.select_program()\",\n \"def get_value(self):\\r\\n return input(\\\"Enter your choice :\\\")\",\n \"def main_menu_selection():\\n action = input('''\\n Pleaes select one:\\n\\n a - Send a thank you\\n b - Create a report\\n c - Quit\\n >''')\\n\\n return action.strip()\",\n \"def menu():\\r\\n \\r\\n choice = int(input((\\\"1.BFS\\\\n2.DFS\\\\n3.BestFS\\\\n4.Beam Search\\\\n5.BBS\\\\n6.A*\\\\n7.Exit\\\\nChoose an option: \\\")))\\r\\n while choice < 1 or choice > 7:\\r\\n print(\\\"Choice is invalid! Try again\\\")\\r\\n choice = int(input((\\\"1.BFS\\\\n3.Beam Search\\\\n4.BBS\\\\n5.A*\\\\n6.Exit\\\\nChoose an option: \\\")))\\r\\n print(\\\"\\\")\\r\\n \\r\\n \\r\\n return choice\",\n \"def home(logger):\\n while True:\\n choice = input(\\n \\\"Please choose: \\\"\\n \\\"(1) view items to deliver, \\\"\\n \\\"(2) view_products, \\\"\\n \\\"(3) add new products, \\\"\\n \\\"(4) update profile, \\\"\\n \\\"(5) log out: \\\"\\n )\\n if choice not in ('1', '2', '3', '4', '5'):\\n logger.log(\\\"Please pick a valid choice\\\")\\n else:\\n break\\n logger.log(\\n \\\"Please choose: \\\"\\n \\\"(1) view items to deliver, \\\"\\n \\\"(2) view_products, \\\"\\n \\\"(3) add new products, \\\"\\n \\\"(4) update profile, \\\"\\n \\\"(5) log out: \\\"\\n f\\\"{choice}\\\"\\n )\\n return choice\",\n \"def menu_page():\\n while True:\\n try:\\n print(\\\"Please choose one of the following options(1,2,3):\\\"\\n \\\"\\\\n1. Send a Thank you. \\\\n2. Create a report\\\"\\n \\\"\\\\n3. Send Letters to Everyone \\\\n4. Quit\\\")\\n option = int(input('--->'))\\n except ValueError:\\n print(\\\"You have made an invalid choice, try again.\\\")\\n page_break()\\n return option\",\n \"def select_file(category, performer=None):\\n\\n files = File.get_files_by_category(category, performer=performer)\\n files_ = []\\n for file in files:\\n if isinstance(file, str):\\n files_.append(PyInquirer.Separator())\\n continue\\n file.category = category\\n file_ = {\\n \\\"name\\\": file.get_title(),\\n \\\"value\\\": file,\\n }\\n files_.append(file_)\\n if len(files_) == 0:\\n Settings.print(\\\"Missing Files\\\")\\n return\\n files_.append({\\n \\\"name\\\": 'Back',\\n \\\"value\\\": None,\\n })\\n question = {\\n 'type': 'list',\\n 'name': 'file',\\n 'message': 'File Path:',\\n 'choices': files_,\\n # 'filter': lambda file: file.lower()\\n }\\n answer = PyInquirer.prompt(question)\\n if not answer: return File.select_files()\\n file = answer[\\\"file\\\"]\\n if not Settings.confirm(file.get_path()): return None\\n return file\",\n \"def logic(ghost):\\n print_pause(\\\"Where do you want to go?\\\\n\\\", 2)\\n choice = input(\\n \\\"Choose on of the following numbers:\\\\n1.\\\" +\\n \\\"Railway station\\\\n\\\" +\\n \\\"2. church street\\\\n3. fort\\\\n\\\").lower()\\n if choice not in \\\"1\\\" and choice not in \\\"2\\\" and choice not in \\\"3\\\":\\n print_pause(\\\"\\\\nSorry I don't understand!\\\", 0)\\n print_pause(\\\"Please repeat the input!\\\\n\\\", 0)\\n logic(ghost)\\n choice1(choice, ghost)\\n choice2(choice, ghost)\\n choice3(choice, ghost)\",\n \"def get_folder():\\n return input(\\\"Folder: \\\")\",\n \"def choose(inp):\\n if not inp.text:\\n return lex.input.missing\\n options = [i.strip() for i in inp.text.split(',') if i.strip()]\\n if not options:\\n return lex.input.incorrect\\n return random.choice(options)\",\n \"def get_input(self):\\n option = input(\\\"Enter the number of your choice: \\\")\\n return option\",\n \"def Infor_file():\\n \\n import os\\n import sys\\n pdbfile_list()\\n\\n file_list = pdbfile_list()\\n\\n items = os.listdir('/home/njesh/python-mini-project-JaneNjeri/PDB_files/')\\n \\n file_list = [name for name in items if name.endswith('.pdb')]\\n\\n for count, fileName in enumerate(file_list, 0):\\n sys.stdout.write(\\\"[%d] %s\\\\n\\\\r\\\" % (count, fileName))\\n\\n choice = int(input(\\\"Select pdb file[0-%s]: \\\" % count))\\n print(file_list[choice])\\n \\n return choice\\n choice = infile\\n Infor_menu()\\n \\n Mainmenu()\",\n \"def menu_choice():\\r\\n choice = ' '\\r\\n while choice not in ['l', 'a', 'i', 'd', 's', 'x']:\\r\\n choice = input('Which operation wouild you like to perform? [l, a, i, d, s or x]: ').lower().strip()\\r\\n print() # Add extra space for layout\\r\\n return choice\",\n \"def question():\\n print('Enter 1 to search database by habitat with detailed information\\\\nEnter 2 to search database by coordinates \\\\nEnter 3 to search by habitat in csv file for a quick overview without detail')\\n print('habitat search options so far:\\\\n Alpenvorland, Niederrheinisches Tiefland, Oberrheinisches Tiefland')\\n src = int(input('Enter here:'))\\n\\n if src == 1:\\n habitat = input('Enter name of habitat\\\\n')\\n query = \\\"habitat = '\\\" + habitat + \\\"'\\\"\\n search_db_via_query(query)\\n elif src == 2:\\n search_by_coordinates()\\n elif src == 3:\\n search_by_habitat()\\n else:\\n print('no data')\",\n \"def prompt():\\r\\n inpt = -1\\r\\n valid_choices = ['1','2','3','4','5']\\r\\n while inpt not in valid_choices:\\r\\n inpt = input(\\\"\\\\nPlease select the number of the operation you wish \\\"\\r\\n \\\"to complete:\\\\n\\\" +\\r\\n \\\"1. Run file mover\\\\n2. Add directories\\\"\\r\\n \\\"\\\\n3. Remove directory\\\\n4. View saved directories\\\\n5. Quit\\\\n\\\").strip()\\r\\n if inpt not in valid_choices:\\r\\n print(\\\"\\\\n*** Invalid choice ***\\\")\\r\\n return inpt\",\n \"def execute_factory_menu(cls):\\n print(\\\"Item Loader\\\")\\n print(\\\"-----------\\\")\\n print(\\\"What kind of items would you like to load?\\\")\\n print(\\\"1. Manga\\\")\\n print(\\\"2. Games\\\")\\n print(\\\"3. Movies\\\")\\n user_choice = int(input(\\\"Enter your choice (1-3):\\\"))\\n factory_type = cls.factory_map[user_choice]\\n\\n file_name = input(\\\"\\\\nEnter file name of the excel file to load from:\\\")\\n return factory_type(file_name)\",\n \"def inputChoice(self, question, options, hotkeys, default=None):\\n options = options[:] # we don't want to edit the passed parameter\\n for i in range(len(options)):\\n option = options[i]\\n hotkey = hotkeys[i]\\n # try to mark a part of the option name as the hotkey\\n m = re.search('[%s%s]' % (hotkey.lower(), hotkey.upper()), option)\\n if hotkey == default:\\n caseHotkey = hotkey.upper()\\n else:\\n caseHotkey = hotkey\\n if m:\\n pos = m.start()\\n options[i] = '%s[%s]%s' % (option[:pos], caseHotkey,\\n option[pos+1:])\\n else:\\n options[i] = '%s [%s]' % (option, caseHotkey)\\n # loop until the user entered a valid choice\\n while True:\\n prompt = '%s (%s)' % (question, ', '.join(options))\\n answer = self.input(prompt)\\n if answer.lower() in hotkeys or answer.upper() in hotkeys:\\n return answer\\n elif default and answer=='': # empty string entered\\n return default\",\n \"def transfer_menu():\\n print(\\\"What type of transfer do you want to use?\\\")\\n for key in sorted(TRANSFER_MENU_SELECTIONS):\\n print(\\\"[%s] %s\\\" % (key, TRANSFER_MENU_SELECTIONS[key]))\\n choice = raw_input(\\\"> \\\")\\n while choice not in list(TRANSFER_MENU_SELECTIONS.keys()):\\n choice = raw_input(\\\"> \\\")\\n return choice\",\n \"def select_input(cls):\\n #Change current working directory to root sdk directory\\n Utility.pushd(Settings.rootSdkPath)\\n print('Would you like to insert release notes?')\\n print('0) Cancel')\\n print('1) Insert directly from command line')\\n print('2) Insert from a file')\\n\\n cls.init()\\n\\n inputValue = 0\\n inputNote = False\\n try:\\n try: input = raw_input\\n except NameError: pass\\n inputValue = input('Select option: ')\\n inputValue = int(inputValue)\\n except SyntaxError:\\n inputValue = 0\\n if inputValue is 0:\\n cls.logger.warning('Failed to create a release note')\\n return False\\n elif inputValue is 1:\\n inputNote = cls.cmd_note()\\n elif inputValue is 2:\\n inputNote = cls.select_file()\\n if inputNote is not False:\\n mode = 'r+' if os.path.exists(Settings.releaseNotePath) else 'w+'\\n with open(Settings.releaseNotePath, mode) as release_notes:\\n oldContent = release_notes.read()\\n release_notes.seek(0, 0)\\n release_notes.write(inputNote.rstrip('\\\\r\\\\n') + '\\\\n' + oldContent)\\n cls.logger.info('Successfuly created release note')\\n # return to the base directory\\n Utility.popd()\\n return inputNote\",\n \"def switch(self, an_input: str):\\n\\n # Empty command\\n if not an_input:\\n print(\\\"\\\")\\n return None\\n\\n (known_args, other_args) = self.etf_parser.parse_known_args(an_input.split())\\n\\n # Help menu again\\n if known_args.cmd == \\\"?\\\":\\n self.print_help()\\n return None\\n\\n # Clear screen\\n if known_args.cmd == \\\"cls\\\":\\n os.system(\\\"cls||clear\\\")\\n return None\\n\\n return getattr(\\n self, \\\"call_\\\" + known_args.cmd, lambda: \\\"Command not recognized!\\\"\\n )(other_args)\",\n \"def ask_for_sync_path():\\n\\n # Enable auto-completion of path and cursor movement using the readline and glob modules\\n def path_completer(text, state):\\n if u\\\"~\\\" in text:\\n text = text.replace(u\\\"~\\\", os.path.expanduser(u\\\"~\\\"))\\n\\n paths = glob.glob(u\\\"%s*\\\" % text)\\n paths.append(False)\\n\\n return os.path.abspath(paths[state]) + u'/'\\n\\n if unix:\\n readline.set_completer_delims(u' \\\\t\\\\n;')\\n readline.parse_and_bind(u\\\"tab: complete\\\")\\n readline.set_completer(path_completer)\\n\\n found = False\\n # Keep asking until a valid path has been entered by the user\\n while not found:\\n sync_path = input(u\\\"\\\\nEnter a relative or absolute path to sync to (~/Desktop/Canvas etc.):\\\\n$ \\\")\\n\\n # Expand tilde if present in the sync_path\\n if u\\\"~\\\" in sync_path:\\n sync_path = sync_path.replace(u\\\"~\\\", os.path.expanduser(u\\\"~\\\"))\\n sync_path = os.path.abspath(sync_path)\\n\\n if not os.path.exists(os.path.split(sync_path)[0]):\\n print(u\\\"\\\\n[ERROR] Base path '%s' does not exist.\\\" % os.path.split(sync_path)[0])\\n else:\\n found = True\\n\\n if unix:\\n # Disable path auto-completer\\n readline.parse_and_bind(u'set disable-completion on')\\n\\n return sync_path\",\n \"def get_filename_as_agrv_if_no_ask(prompt):\\n Found = False\\n ln = len(sys.argv)\\n while not Found:\\n if ln < 2:\\n file = input( prompt)\\n else:\\n file = sys.argv[1]\\n try:\\n RFH = open(file)\\n Found = True\\n except FileNotFoundError:\\n print(\\\"%%Error! File not found!\\\")\\n ln = 1\\n# break\\n return RFH\",\n \"def get_user_choice():\\n while True:\\n direction = input(\\\"Please enter a direction as displayed above(type quit to exit): \\\").strip().upper()\\n possible_directions = [\\\"N\\\", \\\"S\\\", \\\"W\\\", \\\"E\\\", \\\"QUIT\\\"]\\n if direction not in possible_directions:\\n print(\\\"Please enter only directions N, S, W, or E\\\")\\n else:\\n if direction == \\\"QUIT\\\":\\n return \\\"quit\\\"\\n return direction\",\n \"def display():\\r\\n name = input(\\\"Enter the filename:\\\\n\\\")\\r\\n if name==\\\"42.txt\\\":\\r\\n print(f42)\\r\\n elif name == \\\"1015.txt\\\":\\r\\n print(f1015)\\r\\n else:\\r\\n print(\\\"File not found\\\")\",\n \"def do_select(self, line):\\n # Available data sources\\n options = \\\"-csv\\\", \\\"-db\\\"\\n args = list (arg.lower () for arg in str (line).split ())\\n\\n try:\\n # Check if the input data source is available in this program or not\\n if args[0] not in options:\\n raise ValueError (\\\"The data resource is not available.\\\")\\n else:\\n # Code for initialise CSV data source\\n if args[0] == \\\"-csv\\\":\\n try:\\n if len (args) == 1:\\n self._shw.select_source (args[0][1:], \\\"employeeinfo.csv\\\")\\n View.warning (\\n \\\"No CSV file path specified. A default file \\\\\\\"employeeinfo.csv\\\\\\\" will be used.\\\")\\n elif len (args) == 2:\\n self._shw.select_source (args[0][1:], args[1])\\n elif len (args) == 3:\\n if args[1] == \\\"-a\\\":\\n self._shw.select_source (args[0][1:], args[2], True)\\n except (CSVError, OSError) as e:\\n View.error (e)\\n except Exception as e:\\n View.error (e)\\n else:\\n View.success (\\\"Data source CSV is selected.\\\")\\n\\n # Code for initialise database source\\n elif args[0] == \\\"-db\\\":\\n try:\\n self._shw.select_source (args[0][1:])\\n except (ConnectionError, TypeError) as e:\\n View.error (e)\\n except Exception as e:\\n View.error (e)\\n else:\\n View.success (\\\"Data source Database is selected.\\\")\\n\\n # Code for initialise XXXX data source\\n else:\\n pass\\n # Catch and display error message\\n except ValueError as e:\\n View.error (str (e) + \\\"\\\\n\\\")\\n View.help_select ()\\n except Exception as e:\\n View.error (e)\",\n \"def read_path():\\n global path\\n if len(sys.argv) >= 2:\\n path = sys.argv[1]\\n else:\\n path = \\\"train\\\"\",\n \"def select_file_upload_method():\\n\\n if not Settings.prompt(\\\"upload files\\\"): \\n return \\\"unset\\\"\\n Settings.print(\\\"Select an upload source\\\")\\n sources = Settings.get_source_options()\\n question = {\\n 'type': 'list',\\n 'name': 'upload',\\n 'message': 'Upload:',\\n 'choices': [src.title() for src in sources]\\n }\\n upload = PyInquirer.prompt(question)[\\\"upload\\\"]\\n\\n\\n # everything after this part should be in another function\\n # this should just return the string of the upload source\\n\\n\\n if str(upload) == \\\"Local\\\":\\n return File.select_files()\\n elif str(upload) == \\\"Google\\\":\\n return Google_File.select_files()\\n # elif str(upload) == \\\"Dropbox\\\":\\n # return Dropbox.select_files()\\n elif str(upload) == \\\"Remote\\\":\\n return Remote.select_files()\\n return File.select_files()\",\n \"def get_input(prompt, default=None, choices=None, option_value=None):\\r\\n if option_value is not None:\\r\\n return option_value\\r\\n \\r\\n choices = choices or []\\r\\n while 1:\\r\\n r = raw_input(prompt+' ').strip()\\r\\n if not r and default is not None:\\r\\n return default\\r\\n if choices:\\r\\n if r not in choices:\\r\\n r = None\\r\\n else:\\r\\n break\\r\\n else:\\r\\n break\\r\\n return r\"\n]"},"negative_scores":{"kind":"list like","value":["0.6550537","0.62204075","0.61774844","0.61713785","0.6165053","0.61213124","0.6097766","0.6087929","0.60319537","0.60028327","0.59654415","0.5920424","0.59185994","0.59036005","0.5848893","0.5798395","0.5788869","0.5716511","0.5700164","0.56988907","0.5683611","0.5629046","0.5623778","0.561621","0.5597088","0.5579222","0.5576965","0.5563234","0.55550146","0.5546257","0.5540855","0.5540855","0.5521901","0.55179477","0.5511205","0.5508837","0.5503383","0.55026823","0.5491941","0.54876757","0.54766804","0.5467942","0.54505295","0.54461294","0.54319924","0.54274917","0.54249835","0.5408128","0.53945553","0.5387609","0.5387016","0.53833956","0.5357898","0.535224","0.5348514","0.5338532","0.5337121","0.5331009","0.5311084","0.5310432","0.53049046","0.5299616","0.5294007","0.5290523","0.5287872","0.5287735","0.5286779","0.5266507","0.5266069","0.526603","0.52619374","0.5260811","0.5258593","0.525722","0.5254329","0.5253917","0.5249332","0.5247394","0.52395064","0.5236354","0.5230498","0.52281386","0.52181333","0.52060854","0.5197987","0.5195198","0.5194893","0.5193321","0.51930386","0.518885","0.5185377","0.5182879","0.5180011","0.5176222","0.5175351","0.5161326","0.51594085","0.51575845","0.51531774","0.5152769","0.5149774"],"string":"[\n \"0.6550537\",\n \"0.62204075\",\n \"0.61774844\",\n \"0.61713785\",\n \"0.6165053\",\n \"0.61213124\",\n \"0.6097766\",\n \"0.6087929\",\n \"0.60319537\",\n \"0.60028327\",\n \"0.59654415\",\n \"0.5920424\",\n \"0.59185994\",\n \"0.59036005\",\n \"0.5848893\",\n \"0.5798395\",\n \"0.5788869\",\n \"0.5716511\",\n \"0.5700164\",\n \"0.56988907\",\n \"0.5683611\",\n \"0.5629046\",\n \"0.5623778\",\n \"0.561621\",\n \"0.5597088\",\n \"0.5579222\",\n \"0.5576965\",\n \"0.5563234\",\n \"0.55550146\",\n \"0.5546257\",\n \"0.5540855\",\n \"0.5540855\",\n \"0.5521901\",\n \"0.55179477\",\n \"0.5511205\",\n \"0.5508837\",\n \"0.5503383\",\n \"0.55026823\",\n \"0.5491941\",\n \"0.54876757\",\n \"0.54766804\",\n \"0.5467942\",\n \"0.54505295\",\n \"0.54461294\",\n \"0.54319924\",\n \"0.54274917\",\n \"0.54249835\",\n \"0.5408128\",\n \"0.53945553\",\n \"0.5387609\",\n \"0.5387016\",\n \"0.53833956\",\n \"0.5357898\",\n \"0.535224\",\n \"0.5348514\",\n \"0.5338532\",\n \"0.5337121\",\n \"0.5331009\",\n \"0.5311084\",\n \"0.5310432\",\n \"0.53049046\",\n \"0.5299616\",\n \"0.5294007\",\n \"0.5290523\",\n \"0.5287872\",\n \"0.5287735\",\n \"0.5286779\",\n \"0.5266507\",\n \"0.5266069\",\n \"0.526603\",\n \"0.52619374\",\n \"0.5260811\",\n \"0.5258593\",\n \"0.525722\",\n \"0.5254329\",\n \"0.5253917\",\n \"0.5249332\",\n \"0.5247394\",\n \"0.52395064\",\n \"0.5236354\",\n \"0.5230498\",\n \"0.52281386\",\n \"0.52181333\",\n \"0.52060854\",\n \"0.5197987\",\n \"0.5195198\",\n \"0.5194893\",\n \"0.5193321\",\n \"0.51930386\",\n \"0.518885\",\n \"0.5185377\",\n \"0.5182879\",\n \"0.5180011\",\n \"0.5176222\",\n \"0.5175351\",\n \"0.5161326\",\n \"0.51594085\",\n \"0.51575845\",\n \"0.51531774\",\n \"0.5152769\",\n \"0.5149774\"\n]"},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":1690,"cells":{"query":{"kind":"string","value":"Run all dispatch tests"},"document":{"kind":"string","value":"def dispatch():\n suite = ServiceTestSuite()\n suite.addTest(unittest.makeSuite(AmazonTestCase, 'test_dispatch'))\n return suite"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def runTests(self):\n \n pass","def doAllTests(self):\n # Initial offset\n self.getAlertsFile()\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\n\n # Do all tests\n # As the socket is not persistent, client side attacks have to be done before all tests\n for module in self.modules:\n # Test is performed only if selected in config.cfg\n if self.config.get('TESTS', module[1]) == '1':\n print \"\\n%s\\n------------\" % module[0].upper()\n if module[1]=='clientSideAttacks':\n self.doClientSideAttacksTest( clientSideAttacks.ClientSideAttacks(self._target).getPayloads() )\n# elif module[1]=='multipleFailedLogins':\n# self.doMultipleFailedLoginsTest( multipleFailedLogins.MultipleFailedLogins(self._target).getPayloads() )\n else:\n self.doTest( module[1], eval( ('%s.%s'+'(self._target,self._cnf).getPayloads()') % (module[1], module[1][:1].upper()+module[1][1:]) ) )\n\n # Done!\n print \"\\n\\n-----------------------\"\n print \"DONE. Check the report.\"\n print \"-----------------------\\n\"","def test_all():\n test_get_to()\n test_error_type()\n test_exchange()\n print(\"All tests passed.\")","def dispatch():\n suite = ServiceTestSuite()\n suite.addTest(unittest.makeSuite(Test, 'test_dispatch'))\n return suite","def main():\n run_test_all()","def run_tests(self):\n raise NotImplementedError","def runAll():\n\n loader = unittest.TestLoader()\n test_dir = pkg_resources.resource_filename('frvcpy.test','.')\n suite = loader.discover(test_dir)\n\n runner = unittest.TextTestRunner(verbosity=2)\n runner.run(suite)","def run_tests(self):\n\n # log\n self.logger.debug('\\n\\nExecute test methods:\\n-----------------------------')\n\n # test methods start here\n # ------------------------------------------------------------------\n # ------------------------------------------------------------------\n\n # dummy_method\n self.dummy_method()\n\n # ------------------------------------------------------------------\n # ------------------------------------------------------------------\n # test methods end here\n\n # log\n self.logger.debug('\\n\\n-----------------------------\\nFinished test methods.')","def run_all_unit_tests(cls):\n suites_list = []\n for test_class in cls.TESTS:\n suite = unittest.TestLoader().loadTestsFromTestCase(test_class)\n suites_list.append(suite)\n result = unittest.TextTestRunner().run(unittest.TestSuite(suites_list))\n if not result.wasSuccessful() or result.errors:\n raise Exception(result)","def run_all_tests(self):\n for index in range(len(self.__test_set_list)):\n self.run_test(index)","def run_tests():\n \n test_constructor_positive()\n test_constructor_negative()\n test_game_move_positive()\n test_game_move_negative()\n test_game_move_edge()\n print(\"Congratulations ! You passed all the game test cases.\")","def run_all(self):\n failures, errors = [], []\n\n # Run each test case registered with us and agglomerate the results.\n for case_ in self.cases:\n case_.run()\n update_results(failures, errors, case_)\n\n # Display our results.\n print_errors(errors)\n print_failures(failures)\n print_overview(errors, failures)\n\n # Exit with 0 if all tests passed, >0 otherwise.\n sys.exit(len(failures) + len(errors))","def test_all():\n test_prepare_text()\n test_end_chat()\n test_choose_author()\n test_choose_book()","def run_all_tests():\n remove_dbs()\n run_training_tests()\n run_custom_training_tests()\n run_training_save_tests()\n run_validation_tests()\n run_feature_extraction_tests()","def execute(self):\n for test in self.tests:\n test.execute()\n self.logger.dump()\n print(\"Finished!\")","def run(self):\n if self.all:\n cmd = self.apply_options(self.test_all_cmd)\n self.call_and_exit(cmd)\n else:\n cmds = (self.apply_options(self.unit_test_cmd, (\"coverage\",)),)\n if self.coverage:\n cmds += (self.apply_options(self.coverage_cmd),)\n self.call_in_sequence(cmds)","def tests():","def RunAll():\n testfunctions = []\n for name, obj in inspect.getmembers(sys.modules[__name__]):\n if inspect.isfunction(obj) and name != 'RunAll':\n testfunctions.append(obj)\n\n # run all the functions\n for f in testfunctions:\n print('Running %s' % str(f))\n f()","def run_code(self, test):\n for action in test:\n self.assertEquals(1, len(action))\n action_type, action = list(action.items())[0]\n\n if hasattr(self, \"run_\" + action_type):\n getattr(self, \"run_\" + action_type)(action)\n else:\n raise InvalidActionType(action_type)","def runalltests():\n doctest.testmod()","def _run_tests(self):\n for pyunit_testcase in self.cfg.testcases:\n yield self._run_testsuite(pyunit_testcase)","def runtests():\n #- Load all TestCase classes from desistar/test/test_*.py\n tests = desistar_test_suite()\n #- Run them\n unittest.TextTestRunner(verbosity=2).run(tests)","def run_all_tests(self) -> None:\n self.run_trt_precision_tests()\n logging.info(\"Check analysis result at: %s\", self._output_dir)","async def run(self):\n print(\"\".join((\"-\" * 8, type(self).__name__, \"-\" * 8)))\n for method_name in dir(self):\n if not method_name.startswith(\"test\"):\n continue\n print(method_name, end=\"... \")\n try:\n await getattr(self, method_name)()\n except AssertionError:\n print(\"FAIL\")\n traceback.print_exception(*sys.exc_info())\n except Exception: # pylint: disable=broad-except\n print(\"ERROR\")\n traceback.print_exception(*sys.exc_info())\n else:\n print(\"PASS\")\n print()","def runtest(self):","def collectTests(self, global_ctx):\n pass","def __main() :\n launchTests()","def run(self) -> None:\n self.test_sanity()\n if self.has_errors():\n return\n\n tests: List[Callable[[], None]] = [\n self.test_headlines_predefined,\n self.test_headlines_required,\n self.test_headlines_dependencies,\n self.test_headlines_order,\n self.test_headlines_named_entities,\n self.test_named_entities,\n self.test_reading_attributes,\n self.test_forbidden_words,\n self.test_unwanted_words,\n self.test_police_abbreviations,\n self.test_spelling,\n self.test_grammar_rules_regex,\n ]\n\n for test in tests:\n if self.stop_on_error and self.has_errors():\n break\n test()","def run():\n\tsubsuite_list = []\n\tfor _, modname, _ in pkgutil.iter_modules(test.__path__):\n\t\tif modname.startswith(\"test_\"):\n\t\t\tmodule = importlib.import_module('test.' + modname)\n\t\t\tsubsuite = unittest.TestLoader().loadTestsFromModule(module)\n\t\t\tsubsuite_list.append(subsuite)\n\tsuite = unittest.TestSuite(subsuite_list)\n\n\tprint(\"Testing:\\n\")\n\tunittest.TextTestRunner(verbosity=2).run(suite)","def test():\n\n tests = unittest.TestLoader().discover('api/tests/', pattern='*/test_*.py')\n unittest.TextTestRunner(verbosity=2).run(tests)","def tests(context):\n black(context)\n isort(context)\n flake8(context)\n pylint(context)\n yamllint(context)\n pydocstyle(context)\n bandit(context)\n pytest(context)\n\n print(\"All tests have passed!\")","def actionRunUnitTests():\n UnitTestRunner.init()\n \n for target in Settings.targets:\n for platform in Settings.targetPlatforms:\n for cpu in Settings.targetCPUs:\n for configuration in Settings.targetConfigurations:\n if not Summary.checkIfActionFailed(ACTION_BUILD, target, platform, cpu, configuration):\n Logger.printStartActionMessage('Running unit tests for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration, ColoredFormatter.YELLOW)\n result = UnitTestRunner.run(target, platform, cpu, configuration)\n Summary.addSummary(ACTION_RUN_UNITTESTS, target, platform, cpu, configuration, result, UnitTestRunner.executionTime)\n if result != NO_ERROR:\n Logger.printEndActionMessage('Failed to execute unit tests!')\n else:\n Logger.printEndActionMessage('Executed all unit tests')","def run_tests(self):\n with self.report.timer.record(\"run\"):\n self.result.report.extend(self._run_tests())","def runAllTests():\n\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\n\tnTests = ttr.testsRun + len(ttr.skipped)\n\tprint(\"Report:\")\n\tprint(\"\\t\" + str(len(ttr.failures)) + \"/\" + str(nTests) + \" failed\")\n\tprint(\"\\t\" + str(len(ttr.errors)) + \"/\" + str(nTests) + \" errors\")\n\tprint(\"\\t\" + str(len(ttr.skipped)) + \"/\" + str(nTests) + \" skipped\")","def test_methods(self):\n\n #log\n self.logger.debug('\\n\\nExecute test methods:\\n-----------------------------')\n\n\n \n #test methods here\n #------------------------------------------------------------------\n\n #dummy_method\n self.dummy_method()\n\n #------------------------------------------------------------------\n\n\n\n #log\n self.logger.debug('\\n\\n-----------------------------\\nFinished test methods.')","def runTest(self):\n unittest.main()\n ChoreTest.clean_up()","def test_methods(self):\n\n #log\n self.logger.debug('\\n\\nExecute test methods:\\n-----------------------------')\n\n\n \n #test methods here\n #------------------------------------------------------------------\n\n #dummy_method\n self.dummy_method()\n\n #stylesheet_test\n #self.stylesheet_test(self.wdgt_explanation)\n\n #------------------------------------------------------------------\n\n\n\n #log\n self.logger.debug('\\n\\n-----------------------------\\nFinished test methods.')","def RunTestAll(ss):\n ss.StopNow = False\n ss.TestAll()\n ss.Stopped()","def run_tests(tests):\n return [test(t) for t in tests]","def dispatch():\n app.run()","def runTest(self):\n\t\tself.setUp()\n\t\tself.test_postopProgramming1()","def main():\n # add all new test suites per test module here\n suite_date = test_date.suite()\n suite_ng = test_ng.suite()\n suite_page = test_page.suite()\n suite_container = test_container.suite()\n\n # add the suite to be tested here\n alltests = unittest.TestSuite((suite_date,\n suite_ng,\n suite_page,\n suite_container))\n\n # run the suite\n runner = unittest.TextTestRunner()\n runner.run(alltests)","def __run_test_methods(self):\n for test_method in self.runnable_test_methods():\n\n result = TestResult(test_method)\n test_method.im_self.test_result = result\n\n try:\n self._method_level = True # Flag that we're currently running method-level stuff (rather than class-level)\n\n # run \"on-run\" callbacks. eg/ print out the test method name\n for callback in self.__callbacks[self.EVENT_ON_RUN_TEST_METHOD]:\n callback(result.to_dict())\n result.start()\n\n if self.__class_level_failure:\n result.end_in_failure(self.__class_level_failure)\n elif self.__class_level_error:\n result.end_in_error(self.__class_level_error)\n else:\n # first, run setup fixtures\n self._stage = self.STAGE_SETUP\n def _setup_block():\n for fixture_method in self.setup_fixtures + [ self.setUp ]:\n fixture_method()\n self.__execute_block_recording_exceptions(_setup_block, result)\n\n def _run_test_block():\n # then run the test method itself, assuming setup was successful\n self._stage = self.STAGE_TEST_METHOD\n if not result.complete:\n self.__execute_block_recording_exceptions(test_method, result)\n\n def _setup_teardown_block():\n self.__enter_context_managers(self.setup_teardown_fixtures, _run_test_block)\n\n # then run any setup_teardown fixtures, assuming setup was successful.\n if not result.complete:\n self.__execute_block_recording_exceptions(_setup_teardown_block, result)\n\n # finally, run the teardown phase\n self._stage = self.STAGE_TEARDOWN\n def _teardown_block():\n for fixture_method in [ self.tearDown ] + self.teardown_fixtures:\n fixture_method()\n self.__execute_block_recording_exceptions(_teardown_block, result)\n\n # if nothing's gone wrong, it's not about to start\n if not result.complete:\n result.end_in_success()\n except (KeyboardInterrupt, SystemExit):\n result.end_in_interruption(sys.exc_info())\n raise\n finally:\n for callback in self.__callbacks[self.EVENT_ON_COMPLETE_TEST_METHOD]:\n callback(result.to_dict())\n\n self._method_level = False\n\n if not result.success:\n self.failure_count += 1\n if self.failure_limit and self.failure_count >= self.failure_limit:\n return","def test_standard_tap_tests():\n tests = get_standard_tap_tests(TapPartoo, config=SAMPLE_CONFIG)\n for test in tests:\n test()","def run_tests():\n testfiles = ['tests.test_overall']\n exclude = ['__init__.py', 'test_overall.py']\n for t in glob(pjoin('tests', '*.py')):\n if True not in [t.endswith(ex) for ex in exclude]:\n if basename(t).startswith('test_'):\n testfiles.append('tests.%s' % splitext(basename(t))[0])\n\n suites = []\n for file in testfiles:\n __import__(file)\n suites.append(sys.modules[file].suite)\n\n tests = unittest.TestSuite(suites)\n runner = unittest.TextTestRunner(verbosity=2)\n\n # Disable logging output\n logging.basicConfig(level=100)\n logging.disable(100)\n\n result = runner.run(tests)\n return result","def run_all_unit_tests():\n original = verify.parse_content\n try:\n verify.parse_content = parse_string_in_scope\n\n test_list_of()\n\n test_activity_multiple_choice()\n test_activity_free_text()\n test_activity_multiple_choice_group()\n test_activity_ast()\n\n test_assessment()\n test_assessment_ast()\n\n # test existing verifier using parsing instead of exec/compile\n verify.test_sample_assets()\n finally:\n verify.parse_content = original","def RunTest(self):\n self.TestLs()\n self.TestTerminate()\n self.TestMultipleProcesses()","def runall():\n sclogic.runall()","def unittest():\n from a6test import test_all\n test_all()","def test_catchall():\n\n dispatcher = ntelebot.dispatch.Dispatcher()\n dispatcher.add(lambda ctx: 'DISPATCHED')\n ctx = MockContext()\n assert dispatcher(ctx) == 'DISPATCHED'","def spec_tests():\n pass","def run_tests(self):\n manifest = manifestparser.TestManifest(\n manifests=[os.path.join(self.repository_path, self.manifest_path)],\n strict=False)\n\n tests = manifest.active_tests(**mozinfo.info)\n self._mozmill.run(tests, self.options.restart)\n\n # Whenever a test fails it has to be marked, so we quit with the correct exit code\n self.last_failed_tests = self.last_failed_tests or self._mozmill.results.fails\n\n self.testrun_index += 1","def do_test(self):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\tif not self.build['dotest']:\n\t\t\tself.log('Tests configured off, not running',level=logging.DEBUG)\n\t\t\treturn\n\t\t# Test in reverse order\n\t\tself.log('PHASE: test', level=logging.DEBUG)\n\t\tself.stop_all()\n\t\tself.start_all()\n\t\tfor module_id in self.module_ids(rev=True):\n\t\t\t# Only test if it's installed.\n\t\t\tif self.is_installed(self.shutit_map[module_id]):\n\t\t\t\tself.log('RUNNING TEST ON: ' + module_id, level=logging.DEBUG)\n\t\t\t\tself.login(prompt_prefix=module_id,command=shutit_global.shutit_global_object.bash_startup_command,echo=False)\n\t\t\t\tif not self.shutit_map[module_id].test(self):\n\t\t\t\t\tself.fail(module_id + ' failed on test', shutit_pexpect_child=self.get_shutit_pexpect_session_from_id('target_child').pexpect_child) # pragma: no cover\n\t\t\t\tself.logout(echo=False)","def _do_test(self):\n\n process_all_events()\n\n if self.list:\n (callback, args, kwargs) = self.list.pop(0)\n callback(*args, **kwargs)\n else:\n safe_exit(force=1)","def test():\n import unittest\n\n tests = unittest.TestLoader().discover(\"tests\")\n unittest.TextTestRunner(verbosity=2).run(tests)","def test_run_all_some_rule_triggered(self, *args):\n rule1 = {\n 'conditions': 'condition1',\n 'actions': 'action name 1'\n }\n rule2 = {\n 'conditions': 'condition2',\n 'actions': 'action name 2'\n }\n variables = BaseVariables()\n actions = BaseActions()\n\n def return_action1(rule, *args, **kwargs):\n return rule['actions'] == 'action name 1'\n\n engine.run.side_effect = return_action1\n\n result = engine.run_all([rule1, rule2], variables, actions)\n self.assertTrue(result)\n self.assertEqual(engine.run.call_count, 2)\n\n # switch order and try again\n engine.run.reset_mock()\n\n result = engine.run_all([rule2, rule1], variables, actions)\n self.assertTrue(result)\n self.assertEqual(engine.run.call_count, 2)","def test():\n import unittest\n tests = unittest.TestLoader().discover(tests)\n unittest.TextTestRunner(verbosity=2).run(tests)","def test_dispatch(self):\n disp = Dispatcher()\n args = (1, 2)\n res = disp.dispatch(\"working\", *args)\n self.assertEqual(res, args)","def run_feature_extraction_tests():\n test_feature_extraction()\n test_distributed_feature_extraction()\n test_multimodel_feature_extraction()\n test_distributed_multimodel_feature_extraction()","def main():\n run_test_summary1a()\n run_test_summary1c()\n run_test_summary1c()","def run_suite(*test_classes):\n\n loader = unittest.TestLoader()\n suite = unittest.TestSuite()\n for test_class in test_classes:\n tests = loader.loadTestsFromTestCase(test_class)\n suite.addTests(tests)\n if suite is not None:\n unittest.TextTestRunner(verbosity=2).run(suite)\n return","def run_test_suites(self, suites):\n for suite_class in suites:\n test_suite = suite_class(self)\n results = test_suite.run()\n self.test_results += results","def run_combined(self):\n self.runtest_autokey()\n self.runtest_mediaresource()\n self.runtest_composite_slug()\n self.runtest_all_types()\n self.runtest_complex_types()\n self.runtest_only_key()\n self.runtest_compound_key()\n self.runtest_simple_select()\n self.runtest_paging()\n self.runtest_nav_o2o()\n self.runtest_nav_o2o_1()\n self.runtest_nav_zo2o()\n self.runtest_nav_zo2o_f()\n self.runtest_nav_zo2o_b()\n self.runtest_nav_many2o()\n self.runtest_nav_many2o_f()\n self.runtest_nav_many2o_b()\n self.runtest_nav_many2zo()\n self.runtest_nav_many2zo_f()\n self.runtest_nav_many2zo_b()\n self.runtest_nav_many2zo_r()\n self.runtest_nav_many2zo_rf()\n self.runtest_nav_many2zo_rb()\n self.runtest_nav_many2many()\n self.runtest_nav_many2many_1()\n self.runtest_nav_many2many_r()\n self.runtest_nav_many2many_r1()","def startTestRun(self):","def run(self):\n list_test_scenarios = self.__get_list_scenarios_in_folder()\n\n if not list_test_scenarios:\n utils.print_error(\n \"\\n{}\\n\".format(constant.ERR_CANNOT_FIND_ANY_TEST_SCENARIOS))\n exit(1)\n\n (tests_pass, tests_fail) = self.__execute_tests(list_test_scenarios)\n\n complete_message = constant.INFO_TEST_PASS_FAIL.format(\n tests_pass, tests_fail)\n\n print(complete_message)\n\n self.__execute_reporter()","def test():\n import unittest\n testmodules = [\n 'bettermathlib_tests',\n 'randomwebapp_tests',\n ]\n suite = unittest.TestSuite()\n for t in testmodules:\n suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))\n unittest.TextTestRunner(verbosity=2).run(suite)","def test_actions(self, actions):\n try:\n for action in actions:\n self.get_action(action['type'])(**action)\n except Exception as e:\n print('Exception: {}'.format(str(e)))","def run(self):\n\n self.__run_class_setup_fixtures()\n self.__enter_context_managers(self.class_setup_teardown_fixtures, self.__run_test_methods)\n self.__run_class_teardown_fixtures()","def _run_local_tests(self, *args, **kwargs):\n pass","def test():\n test_app()\n test_pagebrowser()","def test(self):\n for arch, python in self.python:\n self.run(f\"{python} -m pytest\")","def run_tests(self):\n # Charm does not defer hooks so that test is not included.\n # Trigger a package change which requires a restart\n self.run_package_change_test(\n 'ovn-central',\n 'ovn-central')","def run_tests(self):\n\n self.endurance_results = []\n self._mozmill.add_listener(self.endurance_event, eventType='mozmill.enduranceResults')\n self._mozmill.persisted['endurance'] = {'delay': self.delay,\n 'iterations': self.options.iterations,\n 'entities': self.options.entities,\n 'restart': self.options.restart}\n\n self.manifest_path = os.path.join('tests', 'endurance')\n if not self.options.reserved:\n self.manifest_path = os.path.join(self.manifest_path,\n \"manifest.ini\")\n else:\n self.manifest_path = os.path.join(self.manifest_path,\n 'reserved',\n self.options.reserved + \".ini\")\n TestRun.run_tests(self)","def run_tests(self, cov, functionsToRun): # pragma: nested\n print(\"runed cases\")\n for context in functionsToRun:\n #print(context)\n info = context.split(\".\")\n suite_name =info[0]\n #print(suite_name)\n className = info[1]\n caseName = info[2]\n cov.start()\n suite = import_local_file(suite_name)\n #print(dir(suite))\n try:\n # Call all functions in this module\n for name in dir(suite):\n variable = getattr(suite, name)\n #print(\"variable.__name__\")\n #print(variable.__name__)\n if inspect.isclass(variable) and variable.__name__== className:\n obj = variable()\n \n memberNames = inspect.getmembers(variable,inspect.isfunction)\n \n for member in memberNames:\n if member[0].startswith('test_') and member[0] == caseName:\n \n print(context)\n getattr(obj, member[0])()\n #if inspect.isfunction(variable):\n # variable()\n finally:\n cov.stop()","def make_all():\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n member[1](master=True)\n print('done!')","def make_all():\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n member[1](master=True)\n print('done!')","def test_basic_execution(self):","def run_test(self):\n raise NotImplementedError","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test_all_circuit_types(self):\n for circuit_type in self.circuits:\n\n # Create a subTest for each type of circuit\n with self.subTest(circuit_type=circuit_type):\n self.check_circuit_type(circuit_type)","def execute_tests():\n\n if len(sys.argv) > 1:\n # Filter test list based on command line requests\n tests_to_run = []\n for requested in sys.argv[1:]:\n for func, param in registered_tests:\n if param == requested:\n tests_to_run += [(func, param)]\n break\n else:\n print('Unknown test ' + requested)\n sys.exit(1)\n else:\n tests_to_run = registered_tests\n\n failing_tests = []\n for func, param in tests_to_run:\n print(param + (' ' * (OUTPUT_ALIGN - len(param))), end='')\n sys.stdout.flush()\n try:\n func(param)\n print(COLOR_GREEN + 'PASS' + COLOR_NONE)\n except KeyboardInterrupt:\n sys.exit(1)\n except TestException as exc:\n print(COLOR_RED + 'FAIL' + COLOR_NONE)\n failing_tests += [(param, exc.args[0])]\n except Exception as exc: # pylint: disable=W0703\n print(COLOR_RED + 'FAIL' + COLOR_NONE)\n failing_tests += [(param, 'Test threw exception:\\n' +\n traceback.format_exc())]\n\n if failing_tests:\n print('Failing tests:')\n for name, output in failing_tests:\n print(name)\n print(output)\n\n print(str(len(failing_tests)) + '/' +\n str(len(tests_to_run)) + ' tests failed')\n if failing_tests != []:\n sys.exit(1)","def run_tests():\n fail = []\n okay = []\n for i in os.listdir(\".\"):\n if i.find(\"_test_\") > -1 and i.endswith(\".py\"):\n if 0 != subprocess.call(\"python \" + i, shell=True):\n fail.append(i)\n else:\n okay.append(i)\n if fail:\n print(\"[ERROR] The following %u tests failed: %r\" % (len(fail), fail))\n return False\n print(\"[DONE] All %u tests completely successfully!\" % (len(okay)))\n return True","def main():\n test_merge_quick_sort()\n test_compare()","def test_dispatch_all0(self):\n req1 = FakeRequest(1, False)\n req2 = FakeRequest(2, False)\n req3 = FakeRequest(3, False)\n req4 = FakeRequest(4, False)\n req5 = FakeRequest(5, False)\n\n self.request_buffer.append(req1)\n self.request_buffer.append(req2)\n self.request_buffer.append(req3)\n self.request_buffer.append(req4)\n self.request_buffer.append(req5)\n\n self.request_buffer.dispatch_all()\n\n self.assertEqual(\n [True]*5,\n [req.dispatched for req in self.request_buffer.requests]\n )","def run_all_tests():\n successes = 0\n testsrun = 0\n testsdir = tests_dirpath()\n for test in os.listdir(testsdir):\n path = os.path.join(testsdir, test)\n if os.path.isdir(path):\n testsrun += 1\n if run_test(path):\n successes += 1\n print(\"--- %d/%d TESTS PASSED ---\" % (successes, testsrun))\n return successes == testsrun","def run_tests(self):\n\n self.test_report = []\n\n #dict of unsorted lists\n dict_of_un_lists = self.dict_un_lists_intersection_test(self.data_dict)\n self.test_report.append(dict_of_un_lists)\n\n #dict of sets\n dict_of_sets = self.build_dict_of_sets(self.data_dict)\n self.test_report.append(self.dict_sets_intersection_test(dict_of_sets))\n\n #pandas - experimental and probably not the way to use pandas\n # dict_of_pandas = self.build_dict_of_panda_series(self.data_dict)\n # self.test_report.append(self.dicts_any_intersection_node_test(dict_of_pandas))\n\n # print results\n\n if self.verbose:\n self.print_tests_results()","def do_test():\n for x in execute_helper(test_info,crossmap_tests):\n yield x","def runTest(self):\n self.setUp()\n self.test_BiplaneRegistration1()","def run_tests(self):\n # Trigger a config change which triggers a deferred hook.\n self.run_charm_change_hook_test('configure_ovs')\n\n # Trigger a package change which requires a restart\n self.run_package_change_test(\n 'openvswitch-switch',\n 'openvswitch-switch')","def run_tests(self):\n # Trigger a config change which triggers a deferred hook.\n self.run_charm_change_hook_test('configure_ovs')\n\n # Trigger a package change which requires a restart\n self.run_package_change_test(\n 'openvswitch-switch',\n 'openvswitch-switch')","def run(self, args):\n start_time = time.time()\n self._printer.write_update('Collecting tests ...')\n running_all_tests = False\n\n try:\n paths, all_test_names, running_all_tests = self._collect_tests(\n args)\n except IOError:\n # This is raised if --test-list doesn't exist\n return test_run_results.RunDetails(\n exit_code=exit_codes.NO_TESTS_EXIT_STATUS)\n\n test_names = self._finder.split_into_chunks(all_test_names)\n if self._options.order == 'natural':\n test_names.sort(key=self._port.test_key)\n elif self._options.order == 'random':\n test_names.sort()\n random.Random(self._options.seed).shuffle(test_names)\n elif self._options.order == 'none':\n # Restore the test order to user specified order.\n # base.tests() may change the order as it returns tests in the\n # real, external/wpt, virtual order.\n if paths:\n test_names = self._restore_order(paths, test_names)\n\n if not self._options.no_expectations:\n self._printer.write_update('Parsing expectations ...')\n self._expectations = test_expectations.TestExpectations(self._port)\n\n tests_to_run, tests_to_skip = self._prepare_lists(paths, test_names)\n\n self._printer.print_found(\n len(all_test_names), len(test_names), len(tests_to_run),\n self._options.repeat_each, self._options.iterations)\n\n # Check to make sure we're not skipping every test.\n if not tests_to_run:\n msg = 'No tests to run.'\n if self._options.zero_tests_executed_ok:\n _log.info(msg)\n # Keep executing to produce valid (but empty) results.\n else:\n _log.critical(msg)\n code = exit_codes.NO_TESTS_EXIT_STATUS\n return test_run_results.RunDetails(exit_code=code)\n\n exit_code = self._set_up_run(tests_to_run)\n if exit_code:\n return test_run_results.RunDetails(exit_code=exit_code)\n\n if self._options.num_retries is None:\n # If --test-list is passed, or if no test narrowing is specified,\n # default to 3 retries. Otherwise [e.g. if tests are being passed by\n # name], default to 0 retries.\n if self._options.test_list or len(paths) < len(test_names):\n self._options.num_retries = 3\n else:\n self._options.num_retries = 0\n\n should_retry_failures = self._options.num_retries > 0\n\n try:\n self._register_termination_handler()\n self._start_servers(tests_to_run)\n if self._options.watch:\n run_results = self._run_test_loop(tests_to_run, tests_to_skip)\n else:\n run_results = self._run_test_once(tests_to_run, tests_to_skip,\n should_retry_failures)\n initial_results, all_retry_results = run_results\n finally:\n _log.info(\"Finally stop servers and clean up\")\n self._stop_servers()\n self._clean_up_run()\n\n if self._options.no_expectations:\n return test_run_results.RunDetails(0, [], [], initial_results,\n all_retry_results)\n\n # Some crash logs can take a long time to be written out so look\n # for new logs after the test run finishes.\n self._printer.write_update('Looking for new crash logs ...')\n self._look_for_new_crash_logs(initial_results, start_time)\n for retry_attempt_results in all_retry_results:\n self._look_for_new_crash_logs(retry_attempt_results, start_time)\n\n self._printer.write_update('Summarizing results ...')\n summarized_full_results = test_run_results.summarize_results(\n self._port, self._options, self._expectations, initial_results,\n all_retry_results)\n summarized_failing_results = test_run_results.summarize_results(\n self._port,\n self._options,\n self._expectations,\n initial_results,\n all_retry_results,\n only_include_failing=True)\n run_histories = test_run_results.test_run_histories(\n self._options, self._expectations, initial_results,\n all_retry_results)\n\n exit_code = summarized_failing_results['num_regressions']\n if exit_code > exit_codes.MAX_FAILURES_EXIT_STATUS:\n _log.warning('num regressions (%d) exceeds max exit status (%d)',\n exit_code, exit_codes.MAX_FAILURES_EXIT_STATUS)\n exit_code = exit_codes.MAX_FAILURES_EXIT_STATUS\n\n if not self._options.dry_run:\n self._write_json_files(summarized_full_results,\n summarized_failing_results, initial_results,\n running_all_tests, run_histories)\n\n self._copy_results_html_file(self._artifacts_directory,\n 'results.html')\n if (initial_results.interrupt_reason is\n test_run_results.InterruptReason.EXTERNAL_SIGNAL):\n exit_code = exit_codes.INTERRUPTED_EXIT_STATUS\n else:\n if initial_results.interrupted:\n exit_code = exit_codes.EARLY_EXIT_STATUS\n if (self._options.show_results\n and (exit_code or initial_results.total_failures)):\n self._port.show_results_html_file(\n self._filesystem.join(self._artifacts_directory,\n 'results.html'))\n self._printer.print_results(time.time() - start_time,\n initial_results)\n\n return test_run_results.RunDetails(exit_code, summarized_full_results,\n summarized_failing_results,\n initial_results, all_retry_results)","def test_dispatch(self):\r\n self.hit = False\r\n\r\n def handler(event):\r\n self.hit = True\r\n\r\n self.events.register(handler, TestEvent)\r\n \r\n self.events.dispatch(TestEvent())\r\n\r\n self.assertTrue(self.hit)","def init(self):\n \n self._nc_session = TestBedTests.TBNetconfSession(self.log, self.loop)\n self._nc_proxy = TestBedTests.TBNetconfProxy(self._nc_session, UtCompositeYang, self.log)\n self._netconf_test_objects = []\n self._pbreq_test_objects = []\n\n for cls in NETCONF_TESTS:\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\n yield from obj.dts_self_register()\n self._netconf_test_objects.append(obj)\n\n for cls in PBREQ_TESTS:\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\n yield from obj.dts_self_register()\n self._pbreq_test_objects.append(obj)\n\n @asyncio.coroutine\n def run_all_tests(xact_info, action, ks_path, msg):\n ro1 = yield from self.run_tests(self._netconf_test_objects, msg.continue_on_failure)\n if ro1.failed_count is 0 or msg.continue_on_failure is True:\n ro2 = yield from self.run_tests(self._pbreq_test_objects, msg.continue_on_failure)\n\n ro = RwAgentTestbedYang.AgentTestsOp()\n ro.total_tests = ro1.total_tests + ro2.total_tests\n ro.passed_count = ro1.passed_count + ro2.passed_count\n ro.failed_count = ro1.failed_count + ro2.failed_count\n #ro.failed_tests = ro1.failed_tests + ro2.failed_tests\n\n xpath = \"O,/agt-tb:agent-tests\"\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\n\n @asyncio.coroutine\n def run_all_netconf_tests(xact_info, action, ks_path, msg):\n ro = yield from self.run_tests(self._netconf_test_objects)\n xpath = \"O,/agt-tb:agent-tests\"\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\n\n @asyncio.coroutine\n def run_all_pbreqs_tests(xact_info, action, ks_path, msg):\n ro = yield from self.run_tests(self._pbreq_test_objects)\n xpath = \"O,/agt-tb:agent-tests\"\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\n \n # Register for all test-cases\n yield from self._dts.register(\n xpath=\"I,/agt-tb:agent-tests/agt-tb:all\",\n flags=rwdts.Flag.PUBLISHER,\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_tests))\n\n # Register for per category all test-cases\n yield from self._dts.register(\n xpath=\"I,/agt-tb:agent-tests/agt-tb:netconf-tests/agt-tb:all\",\n flags=rwdts.Flag.PUBLISHER,\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_netconf_tests))\n\n yield from self._dts.register(\n xpath=\"I,/agt-tb:agent-tests/agt-tb:pb-request-tests/agt-tb:all\",\n flags=rwdts.Flag.PUBLISHER,\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_pbreqs_tests))","def CASE10( self, main ):\n import time\n from tests.CHOTestMonkey.dependencies.events.Event import EventType\n from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod\n\n main.log.report( \"Run all enabled checks\" )\n main.log.report( \"__________________________________________________\" )\n main.case( \"Run all enabled checks\" )\n main.step( \"Run all enabled checks\" )\n main.caseResult = main.TRUE\n main.eventGenerator.triggerEvent( EventType().CHECK_ALL, EventScheduleMethod().RUN_BLOCK )\n # Wait for the scheduler to become idle before going to the next testcase\n with main.eventScheduler.idleCondition:\n while not main.eventScheduler.isIdle():\n main.eventScheduler.idleCondition.wait()\n utilities.assert_equals( expect=main.TRUE,\n actual=main.caseResult,\n onpass=\"All enabled checks passed\",\n onfail=\"Not all enabled checks passed\" )\n time.sleep( main.caseSleep )","def run_test_cases(self):\n count = 1\n for test_case in self.test_cases:\n print(\"Running test case #%d\" % count)\n if test_case.name == 'RouteDistance':\n distance = self.get_distance_for_route(test_case.args)\n print('%s distance: %s' % (test_case.args, distance))\n elif test_case.name == 'RouteShortest':\n args = test_case.args.split('|')\n shortest_distance = self.find_shortest_path_between_cities(args[0], args[1])\n print(\"Shortest distance between %s and %s: %d\" % (args[0], args[1], shortest_distance))\n elif test_case.name == 'RouteLessThanHops':\n args = test_case.args.split('|')\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]))\n print('Paths between %s and %s with hops less than or equal to %d: %d (%s)' % (\n args[0], args[1], int(args[2]), len(paths), paths\n ))\n elif test_case.name == 'RouteEqualHops':\n args = test_case.args.split('|')\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]), equal=True)\n print('Paths between %s and %s with hops equal to %d: %d (%s)' % (\n args[0], args[1], int(args[2]), len(paths), paths\n ))\n elif test_case.name == 'RouteLessThanDistance':\n args = test_case.args.split('|')\n paths = self.trips_distance_constraint_bfs(args[0], args[1], int(args[2]))\n print('Paths between %s and %s with distance less than %d: %d (%s)' % (\n args[0], args[1], int(args[2]), len(paths), paths\n ))\n else:\n raise Exception('Unknown test case: %s' % test_case.name)\n count += 1\n print()","def test_after_jam_step_two(self):\n for test_suite_class in self.jam_step_2_test_suite_list:\n test_suite = test_suite_class(self)\n results = test_suite.run()\n self.test_results += results","def run_single_test(self, config):\n path_name = config['path_name']\n for request in config['request']:\n with self.subTest(request=request, test_name=config['test_name']):\n if 'args' in request:\n url = reverse(path_name, kwargs=request['args'])\n else:\n url = reverse(path_name)\n\n query_params = None\n if 'query_params' in request:\n query_params = urlencode(request['query_params'])\n url = '{}?{}'.format(url, query_params)\n\n data = None\n data_format = 'json'\n if 'data' in request:\n data = request['data']\n\n if 'data_format' in request:\n data_format = request['data_format']\n\n response_check = None\n if 'response_check' in request:\n response_check = request['response_check']\n\n self.call_api(\n url,\n data,\n self.tokens[request['user']],\n request['status'],\n config['type'],\n data_format=data_format,\n response_check=response_check)"],"string":"[\n \"def runTests(self):\\n \\n pass\",\n \"def doAllTests(self):\\n # Initial offset\\n self.getAlertsFile()\\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\\n\\n # Do all tests\\n # As the socket is not persistent, client side attacks have to be done before all tests\\n for module in self.modules:\\n # Test is performed only if selected in config.cfg\\n if self.config.get('TESTS', module[1]) == '1':\\n print \\\"\\\\n%s\\\\n------------\\\" % module[0].upper()\\n if module[1]=='clientSideAttacks':\\n self.doClientSideAttacksTest( clientSideAttacks.ClientSideAttacks(self._target).getPayloads() )\\n# elif module[1]=='multipleFailedLogins':\\n# self.doMultipleFailedLoginsTest( multipleFailedLogins.MultipleFailedLogins(self._target).getPayloads() )\\n else:\\n self.doTest( module[1], eval( ('%s.%s'+'(self._target,self._cnf).getPayloads()') % (module[1], module[1][:1].upper()+module[1][1:]) ) )\\n\\n # Done!\\n print \\\"\\\\n\\\\n-----------------------\\\"\\n print \\\"DONE. Check the report.\\\"\\n print \\\"-----------------------\\\\n\\\"\",\n \"def test_all():\\n test_get_to()\\n test_error_type()\\n test_exchange()\\n print(\\\"All tests passed.\\\")\",\n \"def dispatch():\\n suite = ServiceTestSuite()\\n suite.addTest(unittest.makeSuite(Test, 'test_dispatch'))\\n return suite\",\n \"def main():\\n run_test_all()\",\n \"def run_tests(self):\\n raise NotImplementedError\",\n \"def runAll():\\n\\n loader = unittest.TestLoader()\\n test_dir = pkg_resources.resource_filename('frvcpy.test','.')\\n suite = loader.discover(test_dir)\\n\\n runner = unittest.TextTestRunner(verbosity=2)\\n runner.run(suite)\",\n \"def run_tests(self):\\n\\n # log\\n self.logger.debug('\\\\n\\\\nExecute test methods:\\\\n-----------------------------')\\n\\n # test methods start here\\n # ------------------------------------------------------------------\\n # ------------------------------------------------------------------\\n\\n # dummy_method\\n self.dummy_method()\\n\\n # ------------------------------------------------------------------\\n # ------------------------------------------------------------------\\n # test methods end here\\n\\n # log\\n self.logger.debug('\\\\n\\\\n-----------------------------\\\\nFinished test methods.')\",\n \"def run_all_unit_tests(cls):\\n suites_list = []\\n for test_class in cls.TESTS:\\n suite = unittest.TestLoader().loadTestsFromTestCase(test_class)\\n suites_list.append(suite)\\n result = unittest.TextTestRunner().run(unittest.TestSuite(suites_list))\\n if not result.wasSuccessful() or result.errors:\\n raise Exception(result)\",\n \"def run_all_tests(self):\\n for index in range(len(self.__test_set_list)):\\n self.run_test(index)\",\n \"def run_tests():\\n \\n test_constructor_positive()\\n test_constructor_negative()\\n test_game_move_positive()\\n test_game_move_negative()\\n test_game_move_edge()\\n print(\\\"Congratulations ! You passed all the game test cases.\\\")\",\n \"def run_all(self):\\n failures, errors = [], []\\n\\n # Run each test case registered with us and agglomerate the results.\\n for case_ in self.cases:\\n case_.run()\\n update_results(failures, errors, case_)\\n\\n # Display our results.\\n print_errors(errors)\\n print_failures(failures)\\n print_overview(errors, failures)\\n\\n # Exit with 0 if all tests passed, >0 otherwise.\\n sys.exit(len(failures) + len(errors))\",\n \"def test_all():\\n test_prepare_text()\\n test_end_chat()\\n test_choose_author()\\n test_choose_book()\",\n \"def run_all_tests():\\n remove_dbs()\\n run_training_tests()\\n run_custom_training_tests()\\n run_training_save_tests()\\n run_validation_tests()\\n run_feature_extraction_tests()\",\n \"def execute(self):\\n for test in self.tests:\\n test.execute()\\n self.logger.dump()\\n print(\\\"Finished!\\\")\",\n \"def run(self):\\n if self.all:\\n cmd = self.apply_options(self.test_all_cmd)\\n self.call_and_exit(cmd)\\n else:\\n cmds = (self.apply_options(self.unit_test_cmd, (\\\"coverage\\\",)),)\\n if self.coverage:\\n cmds += (self.apply_options(self.coverage_cmd),)\\n self.call_in_sequence(cmds)\",\n \"def tests():\",\n \"def RunAll():\\n testfunctions = []\\n for name, obj in inspect.getmembers(sys.modules[__name__]):\\n if inspect.isfunction(obj) and name != 'RunAll':\\n testfunctions.append(obj)\\n\\n # run all the functions\\n for f in testfunctions:\\n print('Running %s' % str(f))\\n f()\",\n \"def run_code(self, test):\\n for action in test:\\n self.assertEquals(1, len(action))\\n action_type, action = list(action.items())[0]\\n\\n if hasattr(self, \\\"run_\\\" + action_type):\\n getattr(self, \\\"run_\\\" + action_type)(action)\\n else:\\n raise InvalidActionType(action_type)\",\n \"def runalltests():\\n doctest.testmod()\",\n \"def _run_tests(self):\\n for pyunit_testcase in self.cfg.testcases:\\n yield self._run_testsuite(pyunit_testcase)\",\n \"def runtests():\\n #- Load all TestCase classes from desistar/test/test_*.py\\n tests = desistar_test_suite()\\n #- Run them\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def run_all_tests(self) -> None:\\n self.run_trt_precision_tests()\\n logging.info(\\\"Check analysis result at: %s\\\", self._output_dir)\",\n \"async def run(self):\\n print(\\\"\\\".join((\\\"-\\\" * 8, type(self).__name__, \\\"-\\\" * 8)))\\n for method_name in dir(self):\\n if not method_name.startswith(\\\"test\\\"):\\n continue\\n print(method_name, end=\\\"... \\\")\\n try:\\n await getattr(self, method_name)()\\n except AssertionError:\\n print(\\\"FAIL\\\")\\n traceback.print_exception(*sys.exc_info())\\n except Exception: # pylint: disable=broad-except\\n print(\\\"ERROR\\\")\\n traceback.print_exception(*sys.exc_info())\\n else:\\n print(\\\"PASS\\\")\\n print()\",\n \"def runtest(self):\",\n \"def collectTests(self, global_ctx):\\n pass\",\n \"def __main() :\\n launchTests()\",\n \"def run(self) -> None:\\n self.test_sanity()\\n if self.has_errors():\\n return\\n\\n tests: List[Callable[[], None]] = [\\n self.test_headlines_predefined,\\n self.test_headlines_required,\\n self.test_headlines_dependencies,\\n self.test_headlines_order,\\n self.test_headlines_named_entities,\\n self.test_named_entities,\\n self.test_reading_attributes,\\n self.test_forbidden_words,\\n self.test_unwanted_words,\\n self.test_police_abbreviations,\\n self.test_spelling,\\n self.test_grammar_rules_regex,\\n ]\\n\\n for test in tests:\\n if self.stop_on_error and self.has_errors():\\n break\\n test()\",\n \"def run():\\n\\tsubsuite_list = []\\n\\tfor _, modname, _ in pkgutil.iter_modules(test.__path__):\\n\\t\\tif modname.startswith(\\\"test_\\\"):\\n\\t\\t\\tmodule = importlib.import_module('test.' + modname)\\n\\t\\t\\tsubsuite = unittest.TestLoader().loadTestsFromModule(module)\\n\\t\\t\\tsubsuite_list.append(subsuite)\\n\\tsuite = unittest.TestSuite(subsuite_list)\\n\\n\\tprint(\\\"Testing:\\\\n\\\")\\n\\tunittest.TextTestRunner(verbosity=2).run(suite)\",\n \"def test():\\n\\n tests = unittest.TestLoader().discover('api/tests/', pattern='*/test_*.py')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def tests(context):\\n black(context)\\n isort(context)\\n flake8(context)\\n pylint(context)\\n yamllint(context)\\n pydocstyle(context)\\n bandit(context)\\n pytest(context)\\n\\n print(\\\"All tests have passed!\\\")\",\n \"def actionRunUnitTests():\\n UnitTestRunner.init()\\n \\n for target in Settings.targets:\\n for platform in Settings.targetPlatforms:\\n for cpu in Settings.targetCPUs:\\n for configuration in Settings.targetConfigurations:\\n if not Summary.checkIfActionFailed(ACTION_BUILD, target, platform, cpu, configuration):\\n Logger.printStartActionMessage('Running unit tests for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration, ColoredFormatter.YELLOW)\\n result = UnitTestRunner.run(target, platform, cpu, configuration)\\n Summary.addSummary(ACTION_RUN_UNITTESTS, target, platform, cpu, configuration, result, UnitTestRunner.executionTime)\\n if result != NO_ERROR:\\n Logger.printEndActionMessage('Failed to execute unit tests!')\\n else:\\n Logger.printEndActionMessage('Executed all unit tests')\",\n \"def run_tests(self):\\n with self.report.timer.record(\\\"run\\\"):\\n self.result.report.extend(self._run_tests())\",\n \"def runAllTests():\\n\\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\\n\\tnTests = ttr.testsRun + len(ttr.skipped)\\n\\tprint(\\\"Report:\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.failures)) + \\\"/\\\" + str(nTests) + \\\" failed\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.errors)) + \\\"/\\\" + str(nTests) + \\\" errors\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.skipped)) + \\\"/\\\" + str(nTests) + \\\" skipped\\\")\",\n \"def test_methods(self):\\n\\n #log\\n self.logger.debug('\\\\n\\\\nExecute test methods:\\\\n-----------------------------')\\n\\n\\n \\n #test methods here\\n #------------------------------------------------------------------\\n\\n #dummy_method\\n self.dummy_method()\\n\\n #------------------------------------------------------------------\\n\\n\\n\\n #log\\n self.logger.debug('\\\\n\\\\n-----------------------------\\\\nFinished test methods.')\",\n \"def runTest(self):\\n unittest.main()\\n ChoreTest.clean_up()\",\n \"def test_methods(self):\\n\\n #log\\n self.logger.debug('\\\\n\\\\nExecute test methods:\\\\n-----------------------------')\\n\\n\\n \\n #test methods here\\n #------------------------------------------------------------------\\n\\n #dummy_method\\n self.dummy_method()\\n\\n #stylesheet_test\\n #self.stylesheet_test(self.wdgt_explanation)\\n\\n #------------------------------------------------------------------\\n\\n\\n\\n #log\\n self.logger.debug('\\\\n\\\\n-----------------------------\\\\nFinished test methods.')\",\n \"def RunTestAll(ss):\\n ss.StopNow = False\\n ss.TestAll()\\n ss.Stopped()\",\n \"def run_tests(tests):\\n return [test(t) for t in tests]\",\n \"def dispatch():\\n app.run()\",\n \"def runTest(self):\\n\\t\\tself.setUp()\\n\\t\\tself.test_postopProgramming1()\",\n \"def main():\\n # add all new test suites per test module here\\n suite_date = test_date.suite()\\n suite_ng = test_ng.suite()\\n suite_page = test_page.suite()\\n suite_container = test_container.suite()\\n\\n # add the suite to be tested here\\n alltests = unittest.TestSuite((suite_date,\\n suite_ng,\\n suite_page,\\n suite_container))\\n\\n # run the suite\\n runner = unittest.TextTestRunner()\\n runner.run(alltests)\",\n \"def __run_test_methods(self):\\n for test_method in self.runnable_test_methods():\\n\\n result = TestResult(test_method)\\n test_method.im_self.test_result = result\\n\\n try:\\n self._method_level = True # Flag that we're currently running method-level stuff (rather than class-level)\\n\\n # run \\\"on-run\\\" callbacks. eg/ print out the test method name\\n for callback in self.__callbacks[self.EVENT_ON_RUN_TEST_METHOD]:\\n callback(result.to_dict())\\n result.start()\\n\\n if self.__class_level_failure:\\n result.end_in_failure(self.__class_level_failure)\\n elif self.__class_level_error:\\n result.end_in_error(self.__class_level_error)\\n else:\\n # first, run setup fixtures\\n self._stage = self.STAGE_SETUP\\n def _setup_block():\\n for fixture_method in self.setup_fixtures + [ self.setUp ]:\\n fixture_method()\\n self.__execute_block_recording_exceptions(_setup_block, result)\\n\\n def _run_test_block():\\n # then run the test method itself, assuming setup was successful\\n self._stage = self.STAGE_TEST_METHOD\\n if not result.complete:\\n self.__execute_block_recording_exceptions(test_method, result)\\n\\n def _setup_teardown_block():\\n self.__enter_context_managers(self.setup_teardown_fixtures, _run_test_block)\\n\\n # then run any setup_teardown fixtures, assuming setup was successful.\\n if not result.complete:\\n self.__execute_block_recording_exceptions(_setup_teardown_block, result)\\n\\n # finally, run the teardown phase\\n self._stage = self.STAGE_TEARDOWN\\n def _teardown_block():\\n for fixture_method in [ self.tearDown ] + self.teardown_fixtures:\\n fixture_method()\\n self.__execute_block_recording_exceptions(_teardown_block, result)\\n\\n # if nothing's gone wrong, it's not about to start\\n if not result.complete:\\n result.end_in_success()\\n except (KeyboardInterrupt, SystemExit):\\n result.end_in_interruption(sys.exc_info())\\n raise\\n finally:\\n for callback in self.__callbacks[self.EVENT_ON_COMPLETE_TEST_METHOD]:\\n callback(result.to_dict())\\n\\n self._method_level = False\\n\\n if not result.success:\\n self.failure_count += 1\\n if self.failure_limit and self.failure_count >= self.failure_limit:\\n return\",\n \"def test_standard_tap_tests():\\n tests = get_standard_tap_tests(TapPartoo, config=SAMPLE_CONFIG)\\n for test in tests:\\n test()\",\n \"def run_tests():\\n testfiles = ['tests.test_overall']\\n exclude = ['__init__.py', 'test_overall.py']\\n for t in glob(pjoin('tests', '*.py')):\\n if True not in [t.endswith(ex) for ex in exclude]:\\n if basename(t).startswith('test_'):\\n testfiles.append('tests.%s' % splitext(basename(t))[0])\\n\\n suites = []\\n for file in testfiles:\\n __import__(file)\\n suites.append(sys.modules[file].suite)\\n\\n tests = unittest.TestSuite(suites)\\n runner = unittest.TextTestRunner(verbosity=2)\\n\\n # Disable logging output\\n logging.basicConfig(level=100)\\n logging.disable(100)\\n\\n result = runner.run(tests)\\n return result\",\n \"def run_all_unit_tests():\\n original = verify.parse_content\\n try:\\n verify.parse_content = parse_string_in_scope\\n\\n test_list_of()\\n\\n test_activity_multiple_choice()\\n test_activity_free_text()\\n test_activity_multiple_choice_group()\\n test_activity_ast()\\n\\n test_assessment()\\n test_assessment_ast()\\n\\n # test existing verifier using parsing instead of exec/compile\\n verify.test_sample_assets()\\n finally:\\n verify.parse_content = original\",\n \"def RunTest(self):\\n self.TestLs()\\n self.TestTerminate()\\n self.TestMultipleProcesses()\",\n \"def runall():\\n sclogic.runall()\",\n \"def unittest():\\n from a6test import test_all\\n test_all()\",\n \"def test_catchall():\\n\\n dispatcher = ntelebot.dispatch.Dispatcher()\\n dispatcher.add(lambda ctx: 'DISPATCHED')\\n ctx = MockContext()\\n assert dispatcher(ctx) == 'DISPATCHED'\",\n \"def spec_tests():\\n pass\",\n \"def run_tests(self):\\n manifest = manifestparser.TestManifest(\\n manifests=[os.path.join(self.repository_path, self.manifest_path)],\\n strict=False)\\n\\n tests = manifest.active_tests(**mozinfo.info)\\n self._mozmill.run(tests, self.options.restart)\\n\\n # Whenever a test fails it has to be marked, so we quit with the correct exit code\\n self.last_failed_tests = self.last_failed_tests or self._mozmill.results.fails\\n\\n self.testrun_index += 1\",\n \"def do_test(self):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\tif not self.build['dotest']:\\n\\t\\t\\tself.log('Tests configured off, not running',level=logging.DEBUG)\\n\\t\\t\\treturn\\n\\t\\t# Test in reverse order\\n\\t\\tself.log('PHASE: test', level=logging.DEBUG)\\n\\t\\tself.stop_all()\\n\\t\\tself.start_all()\\n\\t\\tfor module_id in self.module_ids(rev=True):\\n\\t\\t\\t# Only test if it's installed.\\n\\t\\t\\tif self.is_installed(self.shutit_map[module_id]):\\n\\t\\t\\t\\tself.log('RUNNING TEST ON: ' + module_id, level=logging.DEBUG)\\n\\t\\t\\t\\tself.login(prompt_prefix=module_id,command=shutit_global.shutit_global_object.bash_startup_command,echo=False)\\n\\t\\t\\t\\tif not self.shutit_map[module_id].test(self):\\n\\t\\t\\t\\t\\tself.fail(module_id + ' failed on test', shutit_pexpect_child=self.get_shutit_pexpect_session_from_id('target_child').pexpect_child) # pragma: no cover\\n\\t\\t\\t\\tself.logout(echo=False)\",\n \"def _do_test(self):\\n\\n process_all_events()\\n\\n if self.list:\\n (callback, args, kwargs) = self.list.pop(0)\\n callback(*args, **kwargs)\\n else:\\n safe_exit(force=1)\",\n \"def test():\\n import unittest\\n\\n tests = unittest.TestLoader().discover(\\\"tests\\\")\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test_run_all_some_rule_triggered(self, *args):\\n rule1 = {\\n 'conditions': 'condition1',\\n 'actions': 'action name 1'\\n }\\n rule2 = {\\n 'conditions': 'condition2',\\n 'actions': 'action name 2'\\n }\\n variables = BaseVariables()\\n actions = BaseActions()\\n\\n def return_action1(rule, *args, **kwargs):\\n return rule['actions'] == 'action name 1'\\n\\n engine.run.side_effect = return_action1\\n\\n result = engine.run_all([rule1, rule2], variables, actions)\\n self.assertTrue(result)\\n self.assertEqual(engine.run.call_count, 2)\\n\\n # switch order and try again\\n engine.run.reset_mock()\\n\\n result = engine.run_all([rule2, rule1], variables, actions)\\n self.assertTrue(result)\\n self.assertEqual(engine.run.call_count, 2)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover(tests)\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test_dispatch(self):\\n disp = Dispatcher()\\n args = (1, 2)\\n res = disp.dispatch(\\\"working\\\", *args)\\n self.assertEqual(res, args)\",\n \"def run_feature_extraction_tests():\\n test_feature_extraction()\\n test_distributed_feature_extraction()\\n test_multimodel_feature_extraction()\\n test_distributed_multimodel_feature_extraction()\",\n \"def main():\\n run_test_summary1a()\\n run_test_summary1c()\\n run_test_summary1c()\",\n \"def run_suite(*test_classes):\\n\\n loader = unittest.TestLoader()\\n suite = unittest.TestSuite()\\n for test_class in test_classes:\\n tests = loader.loadTestsFromTestCase(test_class)\\n suite.addTests(tests)\\n if suite is not None:\\n unittest.TextTestRunner(verbosity=2).run(suite)\\n return\",\n \"def run_test_suites(self, suites):\\n for suite_class in suites:\\n test_suite = suite_class(self)\\n results = test_suite.run()\\n self.test_results += results\",\n \"def run_combined(self):\\n self.runtest_autokey()\\n self.runtest_mediaresource()\\n self.runtest_composite_slug()\\n self.runtest_all_types()\\n self.runtest_complex_types()\\n self.runtest_only_key()\\n self.runtest_compound_key()\\n self.runtest_simple_select()\\n self.runtest_paging()\\n self.runtest_nav_o2o()\\n self.runtest_nav_o2o_1()\\n self.runtest_nav_zo2o()\\n self.runtest_nav_zo2o_f()\\n self.runtest_nav_zo2o_b()\\n self.runtest_nav_many2o()\\n self.runtest_nav_many2o_f()\\n self.runtest_nav_many2o_b()\\n self.runtest_nav_many2zo()\\n self.runtest_nav_many2zo_f()\\n self.runtest_nav_many2zo_b()\\n self.runtest_nav_many2zo_r()\\n self.runtest_nav_many2zo_rf()\\n self.runtest_nav_many2zo_rb()\\n self.runtest_nav_many2many()\\n self.runtest_nav_many2many_1()\\n self.runtest_nav_many2many_r()\\n self.runtest_nav_many2many_r1()\",\n \"def startTestRun(self):\",\n \"def run(self):\\n list_test_scenarios = self.__get_list_scenarios_in_folder()\\n\\n if not list_test_scenarios:\\n utils.print_error(\\n \\\"\\\\n{}\\\\n\\\".format(constant.ERR_CANNOT_FIND_ANY_TEST_SCENARIOS))\\n exit(1)\\n\\n (tests_pass, tests_fail) = self.__execute_tests(list_test_scenarios)\\n\\n complete_message = constant.INFO_TEST_PASS_FAIL.format(\\n tests_pass, tests_fail)\\n\\n print(complete_message)\\n\\n self.__execute_reporter()\",\n \"def test():\\n import unittest\\n testmodules = [\\n 'bettermathlib_tests',\\n 'randomwebapp_tests',\\n ]\\n suite = unittest.TestSuite()\\n for t in testmodules:\\n suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))\\n unittest.TextTestRunner(verbosity=2).run(suite)\",\n \"def test_actions(self, actions):\\n try:\\n for action in actions:\\n self.get_action(action['type'])(**action)\\n except Exception as e:\\n print('Exception: {}'.format(str(e)))\",\n \"def run(self):\\n\\n self.__run_class_setup_fixtures()\\n self.__enter_context_managers(self.class_setup_teardown_fixtures, self.__run_test_methods)\\n self.__run_class_teardown_fixtures()\",\n \"def _run_local_tests(self, *args, **kwargs):\\n pass\",\n \"def test():\\n test_app()\\n test_pagebrowser()\",\n \"def test(self):\\n for arch, python in self.python:\\n self.run(f\\\"{python} -m pytest\\\")\",\n \"def run_tests(self):\\n # Charm does not defer hooks so that test is not included.\\n # Trigger a package change which requires a restart\\n self.run_package_change_test(\\n 'ovn-central',\\n 'ovn-central')\",\n \"def run_tests(self):\\n\\n self.endurance_results = []\\n self._mozmill.add_listener(self.endurance_event, eventType='mozmill.enduranceResults')\\n self._mozmill.persisted['endurance'] = {'delay': self.delay,\\n 'iterations': self.options.iterations,\\n 'entities': self.options.entities,\\n 'restart': self.options.restart}\\n\\n self.manifest_path = os.path.join('tests', 'endurance')\\n if not self.options.reserved:\\n self.manifest_path = os.path.join(self.manifest_path,\\n \\\"manifest.ini\\\")\\n else:\\n self.manifest_path = os.path.join(self.manifest_path,\\n 'reserved',\\n self.options.reserved + \\\".ini\\\")\\n TestRun.run_tests(self)\",\n \"def run_tests(self, cov, functionsToRun): # pragma: nested\\n print(\\\"runed cases\\\")\\n for context in functionsToRun:\\n #print(context)\\n info = context.split(\\\".\\\")\\n suite_name =info[0]\\n #print(suite_name)\\n className = info[1]\\n caseName = info[2]\\n cov.start()\\n suite = import_local_file(suite_name)\\n #print(dir(suite))\\n try:\\n # Call all functions in this module\\n for name in dir(suite):\\n variable = getattr(suite, name)\\n #print(\\\"variable.__name__\\\")\\n #print(variable.__name__)\\n if inspect.isclass(variable) and variable.__name__== className:\\n obj = variable()\\n \\n memberNames = inspect.getmembers(variable,inspect.isfunction)\\n \\n for member in memberNames:\\n if member[0].startswith('test_') and member[0] == caseName:\\n \\n print(context)\\n getattr(obj, member[0])()\\n #if inspect.isfunction(variable):\\n # variable()\\n finally:\\n cov.stop()\",\n \"def make_all():\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n member[1](master=True)\\n print('done!')\",\n \"def make_all():\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n member[1](master=True)\\n print('done!')\",\n \"def test_basic_execution(self):\",\n \"def run_test(self):\\n raise NotImplementedError\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test_all_circuit_types(self):\\n for circuit_type in self.circuits:\\n\\n # Create a subTest for each type of circuit\\n with self.subTest(circuit_type=circuit_type):\\n self.check_circuit_type(circuit_type)\",\n \"def execute_tests():\\n\\n if len(sys.argv) > 1:\\n # Filter test list based on command line requests\\n tests_to_run = []\\n for requested in sys.argv[1:]:\\n for func, param in registered_tests:\\n if param == requested:\\n tests_to_run += [(func, param)]\\n break\\n else:\\n print('Unknown test ' + requested)\\n sys.exit(1)\\n else:\\n tests_to_run = registered_tests\\n\\n failing_tests = []\\n for func, param in tests_to_run:\\n print(param + (' ' * (OUTPUT_ALIGN - len(param))), end='')\\n sys.stdout.flush()\\n try:\\n func(param)\\n print(COLOR_GREEN + 'PASS' + COLOR_NONE)\\n except KeyboardInterrupt:\\n sys.exit(1)\\n except TestException as exc:\\n print(COLOR_RED + 'FAIL' + COLOR_NONE)\\n failing_tests += [(param, exc.args[0])]\\n except Exception as exc: # pylint: disable=W0703\\n print(COLOR_RED + 'FAIL' + COLOR_NONE)\\n failing_tests += [(param, 'Test threw exception:\\\\n' +\\n traceback.format_exc())]\\n\\n if failing_tests:\\n print('Failing tests:')\\n for name, output in failing_tests:\\n print(name)\\n print(output)\\n\\n print(str(len(failing_tests)) + '/' +\\n str(len(tests_to_run)) + ' tests failed')\\n if failing_tests != []:\\n sys.exit(1)\",\n \"def run_tests():\\n fail = []\\n okay = []\\n for i in os.listdir(\\\".\\\"):\\n if i.find(\\\"_test_\\\") > -1 and i.endswith(\\\".py\\\"):\\n if 0 != subprocess.call(\\\"python \\\" + i, shell=True):\\n fail.append(i)\\n else:\\n okay.append(i)\\n if fail:\\n print(\\\"[ERROR] The following %u tests failed: %r\\\" % (len(fail), fail))\\n return False\\n print(\\\"[DONE] All %u tests completely successfully!\\\" % (len(okay)))\\n return True\",\n \"def main():\\n test_merge_quick_sort()\\n test_compare()\",\n \"def test_dispatch_all0(self):\\n req1 = FakeRequest(1, False)\\n req2 = FakeRequest(2, False)\\n req3 = FakeRequest(3, False)\\n req4 = FakeRequest(4, False)\\n req5 = FakeRequest(5, False)\\n\\n self.request_buffer.append(req1)\\n self.request_buffer.append(req2)\\n self.request_buffer.append(req3)\\n self.request_buffer.append(req4)\\n self.request_buffer.append(req5)\\n\\n self.request_buffer.dispatch_all()\\n\\n self.assertEqual(\\n [True]*5,\\n [req.dispatched for req in self.request_buffer.requests]\\n )\",\n \"def run_all_tests():\\n successes = 0\\n testsrun = 0\\n testsdir = tests_dirpath()\\n for test in os.listdir(testsdir):\\n path = os.path.join(testsdir, test)\\n if os.path.isdir(path):\\n testsrun += 1\\n if run_test(path):\\n successes += 1\\n print(\\\"--- %d/%d TESTS PASSED ---\\\" % (successes, testsrun))\\n return successes == testsrun\",\n \"def run_tests(self):\\n\\n self.test_report = []\\n\\n #dict of unsorted lists\\n dict_of_un_lists = self.dict_un_lists_intersection_test(self.data_dict)\\n self.test_report.append(dict_of_un_lists)\\n\\n #dict of sets\\n dict_of_sets = self.build_dict_of_sets(self.data_dict)\\n self.test_report.append(self.dict_sets_intersection_test(dict_of_sets))\\n\\n #pandas - experimental and probably not the way to use pandas\\n # dict_of_pandas = self.build_dict_of_panda_series(self.data_dict)\\n # self.test_report.append(self.dicts_any_intersection_node_test(dict_of_pandas))\\n\\n # print results\\n\\n if self.verbose:\\n self.print_tests_results()\",\n \"def do_test():\\n for x in execute_helper(test_info,crossmap_tests):\\n yield x\",\n \"def runTest(self):\\n self.setUp()\\n self.test_BiplaneRegistration1()\",\n \"def run_tests(self):\\n # Trigger a config change which triggers a deferred hook.\\n self.run_charm_change_hook_test('configure_ovs')\\n\\n # Trigger a package change which requires a restart\\n self.run_package_change_test(\\n 'openvswitch-switch',\\n 'openvswitch-switch')\",\n \"def run_tests(self):\\n # Trigger a config change which triggers a deferred hook.\\n self.run_charm_change_hook_test('configure_ovs')\\n\\n # Trigger a package change which requires a restart\\n self.run_package_change_test(\\n 'openvswitch-switch',\\n 'openvswitch-switch')\",\n \"def run(self, args):\\n start_time = time.time()\\n self._printer.write_update('Collecting tests ...')\\n running_all_tests = False\\n\\n try:\\n paths, all_test_names, running_all_tests = self._collect_tests(\\n args)\\n except IOError:\\n # This is raised if --test-list doesn't exist\\n return test_run_results.RunDetails(\\n exit_code=exit_codes.NO_TESTS_EXIT_STATUS)\\n\\n test_names = self._finder.split_into_chunks(all_test_names)\\n if self._options.order == 'natural':\\n test_names.sort(key=self._port.test_key)\\n elif self._options.order == 'random':\\n test_names.sort()\\n random.Random(self._options.seed).shuffle(test_names)\\n elif self._options.order == 'none':\\n # Restore the test order to user specified order.\\n # base.tests() may change the order as it returns tests in the\\n # real, external/wpt, virtual order.\\n if paths:\\n test_names = self._restore_order(paths, test_names)\\n\\n if not self._options.no_expectations:\\n self._printer.write_update('Parsing expectations ...')\\n self._expectations = test_expectations.TestExpectations(self._port)\\n\\n tests_to_run, tests_to_skip = self._prepare_lists(paths, test_names)\\n\\n self._printer.print_found(\\n len(all_test_names), len(test_names), len(tests_to_run),\\n self._options.repeat_each, self._options.iterations)\\n\\n # Check to make sure we're not skipping every test.\\n if not tests_to_run:\\n msg = 'No tests to run.'\\n if self._options.zero_tests_executed_ok:\\n _log.info(msg)\\n # Keep executing to produce valid (but empty) results.\\n else:\\n _log.critical(msg)\\n code = exit_codes.NO_TESTS_EXIT_STATUS\\n return test_run_results.RunDetails(exit_code=code)\\n\\n exit_code = self._set_up_run(tests_to_run)\\n if exit_code:\\n return test_run_results.RunDetails(exit_code=exit_code)\\n\\n if self._options.num_retries is None:\\n # If --test-list is passed, or if no test narrowing is specified,\\n # default to 3 retries. Otherwise [e.g. if tests are being passed by\\n # name], default to 0 retries.\\n if self._options.test_list or len(paths) < len(test_names):\\n self._options.num_retries = 3\\n else:\\n self._options.num_retries = 0\\n\\n should_retry_failures = self._options.num_retries > 0\\n\\n try:\\n self._register_termination_handler()\\n self._start_servers(tests_to_run)\\n if self._options.watch:\\n run_results = self._run_test_loop(tests_to_run, tests_to_skip)\\n else:\\n run_results = self._run_test_once(tests_to_run, tests_to_skip,\\n should_retry_failures)\\n initial_results, all_retry_results = run_results\\n finally:\\n _log.info(\\\"Finally stop servers and clean up\\\")\\n self._stop_servers()\\n self._clean_up_run()\\n\\n if self._options.no_expectations:\\n return test_run_results.RunDetails(0, [], [], initial_results,\\n all_retry_results)\\n\\n # Some crash logs can take a long time to be written out so look\\n # for new logs after the test run finishes.\\n self._printer.write_update('Looking for new crash logs ...')\\n self._look_for_new_crash_logs(initial_results, start_time)\\n for retry_attempt_results in all_retry_results:\\n self._look_for_new_crash_logs(retry_attempt_results, start_time)\\n\\n self._printer.write_update('Summarizing results ...')\\n summarized_full_results = test_run_results.summarize_results(\\n self._port, self._options, self._expectations, initial_results,\\n all_retry_results)\\n summarized_failing_results = test_run_results.summarize_results(\\n self._port,\\n self._options,\\n self._expectations,\\n initial_results,\\n all_retry_results,\\n only_include_failing=True)\\n run_histories = test_run_results.test_run_histories(\\n self._options, self._expectations, initial_results,\\n all_retry_results)\\n\\n exit_code = summarized_failing_results['num_regressions']\\n if exit_code > exit_codes.MAX_FAILURES_EXIT_STATUS:\\n _log.warning('num regressions (%d) exceeds max exit status (%d)',\\n exit_code, exit_codes.MAX_FAILURES_EXIT_STATUS)\\n exit_code = exit_codes.MAX_FAILURES_EXIT_STATUS\\n\\n if not self._options.dry_run:\\n self._write_json_files(summarized_full_results,\\n summarized_failing_results, initial_results,\\n running_all_tests, run_histories)\\n\\n self._copy_results_html_file(self._artifacts_directory,\\n 'results.html')\\n if (initial_results.interrupt_reason is\\n test_run_results.InterruptReason.EXTERNAL_SIGNAL):\\n exit_code = exit_codes.INTERRUPTED_EXIT_STATUS\\n else:\\n if initial_results.interrupted:\\n exit_code = exit_codes.EARLY_EXIT_STATUS\\n if (self._options.show_results\\n and (exit_code or initial_results.total_failures)):\\n self._port.show_results_html_file(\\n self._filesystem.join(self._artifacts_directory,\\n 'results.html'))\\n self._printer.print_results(time.time() - start_time,\\n initial_results)\\n\\n return test_run_results.RunDetails(exit_code, summarized_full_results,\\n summarized_failing_results,\\n initial_results, all_retry_results)\",\n \"def test_dispatch(self):\\r\\n self.hit = False\\r\\n\\r\\n def handler(event):\\r\\n self.hit = True\\r\\n\\r\\n self.events.register(handler, TestEvent)\\r\\n \\r\\n self.events.dispatch(TestEvent())\\r\\n\\r\\n self.assertTrue(self.hit)\",\n \"def init(self):\\n \\n self._nc_session = TestBedTests.TBNetconfSession(self.log, self.loop)\\n self._nc_proxy = TestBedTests.TBNetconfProxy(self._nc_session, UtCompositeYang, self.log)\\n self._netconf_test_objects = []\\n self._pbreq_test_objects = []\\n\\n for cls in NETCONF_TESTS:\\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\\n yield from obj.dts_self_register()\\n self._netconf_test_objects.append(obj)\\n\\n for cls in PBREQ_TESTS:\\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\\n yield from obj.dts_self_register()\\n self._pbreq_test_objects.append(obj)\\n\\n @asyncio.coroutine\\n def run_all_tests(xact_info, action, ks_path, msg):\\n ro1 = yield from self.run_tests(self._netconf_test_objects, msg.continue_on_failure)\\n if ro1.failed_count is 0 or msg.continue_on_failure is True:\\n ro2 = yield from self.run_tests(self._pbreq_test_objects, msg.continue_on_failure)\\n\\n ro = RwAgentTestbedYang.AgentTestsOp()\\n ro.total_tests = ro1.total_tests + ro2.total_tests\\n ro.passed_count = ro1.passed_count + ro2.passed_count\\n ro.failed_count = ro1.failed_count + ro2.failed_count\\n #ro.failed_tests = ro1.failed_tests + ro2.failed_tests\\n\\n xpath = \\\"O,/agt-tb:agent-tests\\\"\\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\\n\\n @asyncio.coroutine\\n def run_all_netconf_tests(xact_info, action, ks_path, msg):\\n ro = yield from self.run_tests(self._netconf_test_objects)\\n xpath = \\\"O,/agt-tb:agent-tests\\\"\\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\\n\\n @asyncio.coroutine\\n def run_all_pbreqs_tests(xact_info, action, ks_path, msg):\\n ro = yield from self.run_tests(self._pbreq_test_objects)\\n xpath = \\\"O,/agt-tb:agent-tests\\\"\\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\\n \\n # Register for all test-cases\\n yield from self._dts.register(\\n xpath=\\\"I,/agt-tb:agent-tests/agt-tb:all\\\",\\n flags=rwdts.Flag.PUBLISHER,\\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_tests))\\n\\n # Register for per category all test-cases\\n yield from self._dts.register(\\n xpath=\\\"I,/agt-tb:agent-tests/agt-tb:netconf-tests/agt-tb:all\\\",\\n flags=rwdts.Flag.PUBLISHER,\\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_netconf_tests))\\n\\n yield from self._dts.register(\\n xpath=\\\"I,/agt-tb:agent-tests/agt-tb:pb-request-tests/agt-tb:all\\\",\\n flags=rwdts.Flag.PUBLISHER,\\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_pbreqs_tests))\",\n \"def CASE10( self, main ):\\n import time\\n from tests.CHOTestMonkey.dependencies.events.Event import EventType\\n from tests.CHOTestMonkey.dependencies.EventScheduler import EventScheduleMethod\\n\\n main.log.report( \\\"Run all enabled checks\\\" )\\n main.log.report( \\\"__________________________________________________\\\" )\\n main.case( \\\"Run all enabled checks\\\" )\\n main.step( \\\"Run all enabled checks\\\" )\\n main.caseResult = main.TRUE\\n main.eventGenerator.triggerEvent( EventType().CHECK_ALL, EventScheduleMethod().RUN_BLOCK )\\n # Wait for the scheduler to become idle before going to the next testcase\\n with main.eventScheduler.idleCondition:\\n while not main.eventScheduler.isIdle():\\n main.eventScheduler.idleCondition.wait()\\n utilities.assert_equals( expect=main.TRUE,\\n actual=main.caseResult,\\n onpass=\\\"All enabled checks passed\\\",\\n onfail=\\\"Not all enabled checks passed\\\" )\\n time.sleep( main.caseSleep )\",\n \"def run_test_cases(self):\\n count = 1\\n for test_case in self.test_cases:\\n print(\\\"Running test case #%d\\\" % count)\\n if test_case.name == 'RouteDistance':\\n distance = self.get_distance_for_route(test_case.args)\\n print('%s distance: %s' % (test_case.args, distance))\\n elif test_case.name == 'RouteShortest':\\n args = test_case.args.split('|')\\n shortest_distance = self.find_shortest_path_between_cities(args[0], args[1])\\n print(\\\"Shortest distance between %s and %s: %d\\\" % (args[0], args[1], shortest_distance))\\n elif test_case.name == 'RouteLessThanHops':\\n args = test_case.args.split('|')\\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]))\\n print('Paths between %s and %s with hops less than or equal to %d: %d (%s)' % (\\n args[0], args[1], int(args[2]), len(paths), paths\\n ))\\n elif test_case.name == 'RouteEqualHops':\\n args = test_case.args.split('|')\\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]), equal=True)\\n print('Paths between %s and %s with hops equal to %d: %d (%s)' % (\\n args[0], args[1], int(args[2]), len(paths), paths\\n ))\\n elif test_case.name == 'RouteLessThanDistance':\\n args = test_case.args.split('|')\\n paths = self.trips_distance_constraint_bfs(args[0], args[1], int(args[2]))\\n print('Paths between %s and %s with distance less than %d: %d (%s)' % (\\n args[0], args[1], int(args[2]), len(paths), paths\\n ))\\n else:\\n raise Exception('Unknown test case: %s' % test_case.name)\\n count += 1\\n print()\",\n \"def test_after_jam_step_two(self):\\n for test_suite_class in self.jam_step_2_test_suite_list:\\n test_suite = test_suite_class(self)\\n results = test_suite.run()\\n self.test_results += results\",\n \"def run_single_test(self, config):\\n path_name = config['path_name']\\n for request in config['request']:\\n with self.subTest(request=request, test_name=config['test_name']):\\n if 'args' in request:\\n url = reverse(path_name, kwargs=request['args'])\\n else:\\n url = reverse(path_name)\\n\\n query_params = None\\n if 'query_params' in request:\\n query_params = urlencode(request['query_params'])\\n url = '{}?{}'.format(url, query_params)\\n\\n data = None\\n data_format = 'json'\\n if 'data' in request:\\n data = request['data']\\n\\n if 'data_format' in request:\\n data_format = request['data_format']\\n\\n response_check = None\\n if 'response_check' in request:\\n response_check = request['response_check']\\n\\n self.call_api(\\n url,\\n data,\\n self.tokens[request['user']],\\n request['status'],\\n config['type'],\\n data_format=data_format,\\n response_check=response_check)\"\n]"},"negative_scores":{"kind":"list like","value":["0.7445618","0.72676694","0.72357136","0.7137783","0.69886786","0.69496655","0.69481313","0.6913679","0.6835688","0.6833541","0.68203133","0.68139446","0.6779515","0.67011243","0.6626831","0.66243935","0.6614983","0.65842265","0.6561729","0.6560582","0.6522628","0.6441573","0.6411267","0.6393447","0.6377413","0.6375661","0.635919","0.6357565","0.6333101","0.6329656","0.6311414","0.62818956","0.6278038","0.6248356","0.62319","0.6221192","0.6200442","0.6184826","0.6169045","0.6164405","0.61500186","0.614703","0.61333734","0.613047","0.6121119","0.61183864","0.6113423","0.6111994","0.6102002","0.6094369","0.60917616","0.60893476","0.608665","0.60725355","0.60693014","0.60576034","0.60570395","0.6048917","0.60480064","0.6047662","0.6036021","0.6026652","0.60247463","0.6018374","0.6010244","0.6003191","0.59893966","0.5970744","0.596313","0.5961926","0.59518117","0.59466994","0.59456545","0.5942728","0.5928756","0.5928756","0.5921319","0.5914724","0.59079313","0.5892017","0.5892017","0.5892017","0.5891779","0.5876384","0.5874596","0.5873433","0.5865875","0.58601546","0.5856308","0.5856233","0.58452326","0.5844174","0.5844174","0.5843423","0.5841481","0.5830591","0.58252394","0.5821749","0.5819941","0.5819165"],"string":"[\n \"0.7445618\",\n \"0.72676694\",\n \"0.72357136\",\n \"0.7137783\",\n \"0.69886786\",\n \"0.69496655\",\n \"0.69481313\",\n \"0.6913679\",\n \"0.6835688\",\n \"0.6833541\",\n \"0.68203133\",\n \"0.68139446\",\n \"0.6779515\",\n \"0.67011243\",\n \"0.6626831\",\n \"0.66243935\",\n \"0.6614983\",\n \"0.65842265\",\n \"0.6561729\",\n \"0.6560582\",\n \"0.6522628\",\n \"0.6441573\",\n \"0.6411267\",\n \"0.6393447\",\n \"0.6377413\",\n \"0.6375661\",\n \"0.635919\",\n \"0.6357565\",\n \"0.6333101\",\n \"0.6329656\",\n \"0.6311414\",\n \"0.62818956\",\n \"0.6278038\",\n \"0.6248356\",\n \"0.62319\",\n \"0.6221192\",\n \"0.6200442\",\n \"0.6184826\",\n \"0.6169045\",\n \"0.6164405\",\n \"0.61500186\",\n \"0.614703\",\n \"0.61333734\",\n \"0.613047\",\n \"0.6121119\",\n \"0.61183864\",\n \"0.6113423\",\n \"0.6111994\",\n \"0.6102002\",\n \"0.6094369\",\n \"0.60917616\",\n \"0.60893476\",\n \"0.608665\",\n \"0.60725355\",\n \"0.60693014\",\n \"0.60576034\",\n \"0.60570395\",\n \"0.6048917\",\n \"0.60480064\",\n \"0.6047662\",\n \"0.6036021\",\n \"0.6026652\",\n \"0.60247463\",\n \"0.6018374\",\n \"0.6010244\",\n \"0.6003191\",\n \"0.59893966\",\n \"0.5970744\",\n \"0.596313\",\n \"0.5961926\",\n \"0.59518117\",\n \"0.59466994\",\n \"0.59456545\",\n \"0.5942728\",\n \"0.5928756\",\n \"0.5928756\",\n \"0.5921319\",\n \"0.5914724\",\n \"0.59079313\",\n \"0.5892017\",\n \"0.5892017\",\n \"0.5892017\",\n \"0.5891779\",\n \"0.5876384\",\n \"0.5874596\",\n \"0.5873433\",\n \"0.5865875\",\n \"0.58601546\",\n \"0.5856308\",\n \"0.5856233\",\n \"0.58452326\",\n \"0.5844174\",\n \"0.5844174\",\n \"0.5843423\",\n \"0.5841481\",\n \"0.5830591\",\n \"0.58252394\",\n \"0.5821749\",\n \"0.5819941\",\n \"0.5819165\"\n]"},"document_score":{"kind":"string","value":"0.6487395"},"document_rank":{"kind":"string","value":"21"}}},{"rowIdx":1691,"cells":{"query":{"kind":"string","value":"Run all local tests"},"document":{"kind":"string","value":"def local():\n suite = ServiceTestSuite()\n suite.addTest(unittest.makeSuite(AmazonTestCase, 'test_local'))\n return suite"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _run_local_tests(self, *args, **kwargs):\n pass","def runAll():\n\n loader = unittest.TestLoader()\n test_dir = pkg_resources.resource_filename('frvcpy.test','.')\n suite = loader.discover(test_dir)\n\n runner = unittest.TextTestRunner(verbosity=2)\n runner.run(suite)","def main():\n run_test_all()","def tests():\n api.local('nosetests')","def runalltests():\n doctest.testmod()","def run_test_suite():\n local('. fabric_factory/ve/bin/activate; fabric_factory/src/project/manage.py test')","def runTests(self):\n \n pass","def run_all_tests():\n remove_dbs()\n run_training_tests()\n run_custom_training_tests()\n run_training_save_tests()\n run_validation_tests()\n run_feature_extraction_tests()","def test(self):\n for arch, python in self.python:\n self.run(f\"{python} -m pytest\")","def run_tests(self):\n\n self.manifest_path = os.path.join('tests',\n 'remote',\n 'manifest.ini')\n TestRun.run_tests(self)","def run_all_tests(self):\n for index in range(len(self.__test_set_list)):\n self.run_test(index)","def run_all_unit_tests(cls):\n suites_list = []\n for test_class in cls.TESTS:\n suite = unittest.TestLoader().loadTestsFromTestCase(test_class)\n suites_list.append(suite)\n result = unittest.TextTestRunner().run(unittest.TestSuite(suites_list))\n if not result.wasSuccessful() or result.errors:\n raise Exception(result)","def local_test():\n pass","def run_tests(self):\n\n self.manifest_path = os.path.join('tests',\n 'functional',\n 'manifest.ini')\n TestRun.run_tests(self)","def test_all():\n test_get_to()\n test_error_type()\n test_exchange()\n print(\"All tests passed.\")","def RunTestAll(ss):\n ss.StopNow = False\n ss.TestAll()\n ss.Stopped()","def run():\n\tsubsuite_list = []\n\tfor _, modname, _ in pkgutil.iter_modules(test.__path__):\n\t\tif modname.startswith(\"test_\"):\n\t\t\tmodule = importlib.import_module('test.' + modname)\n\t\t\tsubsuite = unittest.TestLoader().loadTestsFromModule(module)\n\t\t\tsubsuite_list.append(subsuite)\n\tsuite = unittest.TestSuite(subsuite_list)\n\n\tprint(\"Testing:\\n\")\n\tunittest.TextTestRunner(verbosity=2).run(suite)","def runtests():\n #- Load all TestCase classes from desistar/test/test_*.py\n tests = desistar_test_suite()\n #- Run them\n unittest.TextTestRunner(verbosity=2).run(tests)","def run_tests():\n testfiles = ['tests.test_overall']\n exclude = ['__init__.py', 'test_overall.py']\n for t in glob(pjoin('tests', '*.py')):\n if True not in [t.endswith(ex) for ex in exclude]:\n if basename(t).startswith('test_'):\n testfiles.append('tests.%s' % splitext(basename(t))[0])\n\n suites = []\n for file in testfiles:\n __import__(file)\n suites.append(sys.modules[file].suite)\n\n tests = unittest.TestSuite(suites)\n runner = unittest.TextTestRunner(verbosity=2)\n\n # Disable logging output\n logging.basicConfig(level=100)\n logging.disable(100)\n\n result = runner.run(tests)\n return result","def run_tests():\n fail = []\n okay = []\n for i in os.listdir(\".\"):\n if i.find(\"_test_\") > -1 and i.endswith(\".py\"):\n if 0 != subprocess.call(\"python \" + i, shell=True):\n fail.append(i)\n else:\n okay.append(i)\n if fail:\n print(\"[ERROR] The following %u tests failed: %r\" % (len(fail), fail))\n return False\n print(\"[DONE] All %u tests completely successfully!\" % (len(okay)))\n return True","def run_all_tests(self) -> None:\n self.run_trt_precision_tests()\n logging.info(\"Check analysis result at: %s\", self._output_dir)","def tests():","def test():\n for cmd in [\n \"pytest --verbose --cov pike/ --cov-report term --cov-report html tests/\",\n ]:\n _run_in_venv(shlex.split(cmd))\n for linter in [[\"black\", \"--check\"], [\"flake8\"], [\"isort\", \"--check\"]]:\n _run_in_venv(linter + TEST_FILES)\n\n _run_in_venv(\n [\"mypy\", \"pike/\", \"tests/\", \"setup.py\", \"pikefile.py\", \"--show-error-codes\"]\n )\n _run_in_venv([\"mypy\", \"examples/\"])\n _run_in_venv([\"bandit\", \"-r\", \"pike/\"])","def _run_ci_test():\n _run_install(False)\n _run_coverage_html(False)\n _run_typecheck_xml(False)\n _run_lint(True)","def runtests(ctx):\n run('pytest -s tests', pty=pty_available)\n run('flake8 --ignore E265,E266,E501 --exclude src, lib', pty=pty_available)","def doAllTests(self):\n # Initial offset\n self.getAlertsFile()\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\n\n # Do all tests\n # As the socket is not persistent, client side attacks have to be done before all tests\n for module in self.modules:\n # Test is performed only if selected in config.cfg\n if self.config.get('TESTS', module[1]) == '1':\n print \"\\n%s\\n------------\" % module[0].upper()\n if module[1]=='clientSideAttacks':\n self.doClientSideAttacksTest( clientSideAttacks.ClientSideAttacks(self._target).getPayloads() )\n# elif module[1]=='multipleFailedLogins':\n# self.doMultipleFailedLoginsTest( multipleFailedLogins.MultipleFailedLogins(self._target).getPayloads() )\n else:\n self.doTest( module[1], eval( ('%s.%s'+'(self._target,self._cnf).getPayloads()') % (module[1], module[1][:1].upper()+module[1][1:]) ) )\n\n # Done!\n print \"\\n\\n-----------------------\"\n print \"DONE. Check the report.\"\n print \"-----------------------\\n\"","def main():\n # add all new test suites per test module here\n suite_date = test_date.suite()\n suite_ng = test_ng.suite()\n suite_page = test_page.suite()\n suite_container = test_container.suite()\n\n # add the suite to be tested here\n alltests = unittest.TestSuite((suite_date,\n suite_ng,\n suite_page,\n suite_container))\n\n # run the suite\n runner = unittest.TextTestRunner()\n runner.run(alltests)","def __main() :\n launchTests()","def run_tests(tests):\n return [test(t) for t in tests]","def runAllTests():\n\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\n\tnTests = ttr.testsRun + len(ttr.skipped)\n\tprint(\"Report:\")\n\tprint(\"\\t\" + str(len(ttr.failures)) + \"/\" + str(nTests) + \" failed\")\n\tprint(\"\\t\" + str(len(ttr.errors)) + \"/\" + str(nTests) + \" errors\")\n\tprint(\"\\t\" + str(len(ttr.skipped)) + \"/\" + str(nTests) + \" skipped\")","def run_tests(self):\n\n self.manifest_path = os.path.join('tests',\n 'l10n',\n 'manifest.ini')\n TestRun.run_tests(self)","def run_tests(self):\n raise NotImplementedError","def _run_tests(self):\n for pyunit_testcase in self.cfg.testcases:\n yield self._run_testsuite(pyunit_testcase)","def test():\n import unittest\n\n tests = unittest.TestLoader().discover(\"tests\")\n unittest.TextTestRunner(verbosity=2).run(tests)","def collectTests(self, global_ctx):\n pass","def run_tests():\n test_command = \"pytest -s \" + os.path.join(root_path, \"cases\", \"test_cases.py::TestCases::test_cases\") + \" --html=\" + os.path.join(root_path, \"reports\", \"qa_testing_report.html\")\n\n subprocess.run(test_command, shell=True)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def tests(context):\n black(context)\n isort(context)\n flake8(context)\n pylint(context)\n yamllint(context)\n pydocstyle(context)\n bandit(context)\n pytest(context)\n\n print(\"All tests have passed!\")","def test_all():\n test_prepare_text()\n test_end_chat()\n test_choose_author()\n test_choose_book()","def RunAll():\n testfunctions = []\n for name, obj in inspect.getmembers(sys.modules[__name__]):\n if inspect.isfunction(obj) and name != 'RunAll':\n testfunctions.append(obj)\n\n # run all the functions\n for f in testfunctions:\n print('Running %s' % str(f))\n f()","def runtest(self):","def run_all(self):\n failures, errors = [], []\n\n # Run each test case registered with us and agglomerate the results.\n for case_ in self.cases:\n case_.run()\n update_results(failures, errors, case_)\n\n # Display our results.\n print_errors(errors)\n print_failures(failures)\n print_overview(errors, failures)\n\n # Exit with 0 if all tests passed, >0 otherwise.\n sys.exit(len(failures) + len(errors))","def run_all_tests():\n successes = 0\n testsrun = 0\n testsdir = tests_dirpath()\n for test in os.listdir(testsdir):\n path = os.path.join(testsdir, test)\n if os.path.isdir(path):\n testsrun += 1\n if run_test(path):\n successes += 1\n print(\"--- %d/%d TESTS PASSED ---\" % (successes, testsrun))\n return successes == testsrun","def unittest():\n from a6test import test_all\n test_all()","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def runtests():\r\n\r\n app_abspath = os.path.dirname(os.path.dirname(__file__))\r\n models_abspath = os.path.join(app_abspath, 'models.py')\r\n models_exists = os.path.isfile(models_abspath)\r\n urls_abspath = os.path.join(app_abspath, 'urls.py')\r\n urls_exists = os.path.isfile(urls_abspath)\r\n views_abspath = os.path.join(app_abspath, 'views')\r\n views_exists = os.path.isdir(views_abspath)\r\n tpls_abspath = os.path.join(app_abspath, 'templates')\r\n tpls_exists = os.path.isdir(tpls_abspath)\r\n\r\n for f in [models_abspath, urls_abspath]:\r\n if os.path.isfile(f):\r\n subprocess.call('cp {} {}.orig'.format(f, f), shell=True)\r\n\r\n if views_exists:\r\n subprocess.call('cp -r {} {}.orig'.format(views_abspath, views_abspath), shell=True)\r\n\r\n if tpls_exists:\r\n subprocess.call('cp -r {} {}.orig'.format(tpls_abspath, tpls_abspath), shell=True)\r\n\r\n overwrite_project_language('ja')\r\n subprocess.call('python manage.py generatescaffold test_app I18nModel title:string', shell=True)\r\n time.sleep(1)\r\n overwrite_project_language('en-us')\r\n time.sleep(1)\r\n\r\n subprocess.call('python manage.py generatescaffold test_app GeneratedNoTimestampModel title:string description:text --no-timestamps', shell=True)\r\n time.sleep(2) # Give time for Django's AppCache to clear\r\n\r\n subprocess.call('python manage.py generatescaffold test_app GeneratedModel title:string description:text', shell=True)\r\n\r\n test_status = subprocess.call('python manage.py test --with-selenium --with-selenium-fixtures --with-cherrypyliveserver --noinput', shell=True)\r\n\r\n if models_exists:\r\n subprocess.call('mv {}.orig {}'.format(models_abspath, models_abspath), shell=True)\r\n else:\r\n subprocess.call('rm {}'.format(models_abspath), shell=True)\r\n\r\n if urls_exists:\r\n subprocess.call('mv {}.orig {}'.format(urls_abspath, urls_abspath), shell=True)\r\n else:\r\n subprocess.call('rm {}'.format(urls_abspath), shell=True)\r\n\r\n if views_exists:\r\n subprocess.call('rm -rf {}'.format(views_abspath), shell=True)\r\n subprocess.call('mv {}.orig {}'.format(views_abspath, views_abspath), shell=True)\r\n else:\r\n subprocess.call('rm -rf {}'.format(views_abspath), shell=True)\r\n\r\n if tpls_exists:\r\n subprocess.call('rm -rf {}'.format(tpls_abspath), shell=True)\r\n subprocess.call('mv {}.orig {}'.format(tpls_abspath, tpls_abspath), shell=True)\r\n else:\r\n subprocess.call('rm -rf {}'.format(tpls_abspath), shell=True)\r\n\r\n subprocess.call('rm {}/*.pyc'.format(app_abspath), shell=True)\r\n\r\n sys.exit(test_status)","def django_run_tests():\r\n \r\n settings_py, manage_py = _CDjangoPluginActivator._instance._FindKeyFiles()\r\n loc = location.CreateFromName(settings_py)\r\n cmd = 'run_test_files(locs=\"%s\")' % settings_py\r\n wingapi.gApplication.ExecuteCommand(cmd)","def test():\n import unittest\n tests = unittest.TestLoader().discover(tests)\n unittest.TextTestRunner(verbosity=2).run(tests)","def run_tests():\n argument_parser = ArgumentParser(description=\"Run all tests for {{project name}}\")\n #TODO add some configuration here\n\n settings.configure(**{\n \"DATABASE_ENGINE\" : \"django.db.backends.sqlite3\",\n \"DATABASE_NAME\" : \"sqlite://:memory:\",\n \"ROOT_URLCONF\" : \"tests.urls\",\n \"TEMPLATE_LOADERS\" : (\n \"django.template.loaders.filesystem.load_template_source\",\n \"django.template.loaders.app_directory.load_template_source\",\n ),\n \"TEMPLATE_DIRS\" : (\n path(__file__).dirname() / 'templates',\n ),\n \"INSTALLED_APPS\" : (\n 'django.contrib.admin',\n 'django.contrib.auth',\n 'django.contrib.contenttypes',\n 'django.contrib.sessions',\n 'django.contrib.sites',\n '{{ project_name }},\n ),\n })\n call_command(\"test\")","def test():\n import unittest\n testmodules = [\n 'bettermathlib_tests',\n 'randomwebapp_tests',\n ]\n suite = unittest.TestSuite()\n for t in testmodules:\n suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))\n unittest.TextTestRunner(verbosity=2).run(suite)","def main():\n fix_sys_path()\n result = unittest.TextTestRunner(verbosity=2).run(createTestSuite())\n\n if result.testsRun != EXPECTED_TEST_COUNT:\n raise Exception(\n 'Expected %s tests to be run, not %s.' % (EXPECTED_TEST_COUNT, result.testsRun))\n\n if len(result.errors) != 0 or len(result.failures) != 0:\n raise Exception(\n \"Functional test suite failed: %s errors, %s failures of %s tests run.\" % (\n len(result.errors), len(result.failures), result.testsRun))","def test():\n\n tests = unittest.TestLoader().discover('api/tests/', pattern='*/test_*.py')\n unittest.TextTestRunner(verbosity=2).run(tests)","def run_tests(self):\n manifest = manifestparser.TestManifest(\n manifests=[os.path.join(self.repository_path, self.manifest_path)],\n strict=False)\n\n tests = manifest.active_tests(**mozinfo.info)\n self._mozmill.run(tests, self.options.restart)\n\n # Whenever a test fails it has to be marked, so we quit with the correct exit code\n self.last_failed_tests = self.last_failed_tests or self._mozmill.results.fails\n\n self.testrun_index += 1","def do_test(self):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\tif not self.build['dotest']:\n\t\t\tself.log('Tests configured off, not running',level=logging.DEBUG)\n\t\t\treturn\n\t\t# Test in reverse order\n\t\tself.log('PHASE: test', level=logging.DEBUG)\n\t\tself.stop_all()\n\t\tself.start_all()\n\t\tfor module_id in self.module_ids(rev=True):\n\t\t\t# Only test if it's installed.\n\t\t\tif self.is_installed(self.shutit_map[module_id]):\n\t\t\t\tself.log('RUNNING TEST ON: ' + module_id, level=logging.DEBUG)\n\t\t\t\tself.login(prompt_prefix=module_id,command=shutit_global.shutit_global_object.bash_startup_command,echo=False)\n\t\t\t\tif not self.shutit_map[module_id].test(self):\n\t\t\t\t\tself.fail(module_id + ' failed on test', shutit_pexpect_child=self.get_shutit_pexpect_session_from_id('target_child').pexpect_child) # pragma: no cover\n\t\t\t\tself.logout(echo=False)","def run_tests(virtual_env):\n signal.signal(signal.SIGINT, signal.SIG_IGN)\n args = [\n 'python',\n 'setup.py',\n 'nosetests',\n '--with-coverage',\n '--with-xunit',\n ]\n subprocess.call(args, cwd=abspath(join(HOLLAND_ROOT, 'holland-core')), env=virtual_env)\n subprocess.call(['coverage', 'xml'], cwd=abspath(join(HOLLAND_ROOT, 'holland-core')), env=virtual_env)\n for plugin_dir in open(join(HOLLAND_ROOT, 'plugins', 'ACTIVE')):\n plugin_dir = plugin_dir.rstrip()\n plugin_path = join(HOLLAND_ROOT, 'plugins', plugin_dir)\n subprocess.call(args, cwd=plugin_path, env=virtual_env)\n subprocess.call(['coverage', 'xml'], cwd=plugin_path, env=virtual_env)\n for addon_dir in open(join(HOLLAND_ROOT, 'addons', 'ACTIVE')):\n addon_dir = addon_dir.rstrip()\n addon_path = join(HOLLAND_ROOT, 'addons', addon_dir)\n subprocess.call(args, cwd=addon_path, env=virtual_env)\n subprocess.call(['coverage', 'xml'], cwd=plugin_path, env=virtual_env)\n #return subprocess.call(args, env=virtual_env)","def run_tests(self):\n # Charm does not defer hooks so that test is not included.\n # Trigger a package change which requires a restart\n self.run_package_change_test(\n 'ovn-central',\n 'ovn-central')","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n\n tests = unittest.TestLoader().discover(\"tests\")\n unittest.TextTestRunner(verbosity=2).run(tests)","def execute(self):\n for test in self.tests:\n test.execute()\n self.logger.dump()\n print(\"Finished!\")","def test():\r\n import unittest\r\n tests = unittest.TestLoader().discover('tests')\r\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\r\n import unittest\r\n tests = unittest.TestLoader().discover('tests')\r\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\r\n import unittest\r\n tests=unittest.TestLoader().discover('tests')\r\n unittest.TextTestRunner(verbosity=2).run(tests)","def run_all_unit_tests():\n original = verify.parse_content\n try:\n verify.parse_content = parse_string_in_scope\n\n test_list_of()\n\n test_activity_multiple_choice()\n test_activity_free_text()\n test_activity_multiple_choice_group()\n test_activity_ast()\n\n test_assessment()\n test_assessment_ast()\n\n # test existing verifier using parsing instead of exec/compile\n verify.test_sample_assets()\n finally:\n verify.parse_content = original","def test():\n loader = unittest.TestLoader()\n suite = loader.discover(os.path.dirname(__file__))\n runner = unittest.TextTestRunner()\n runner.run(suite)","def test():\n import unittest\n\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n import unittest\n import tests\n tests = unittest.TestLoader().discover('tests', pattern='*tests.py')\n unittest.TextTestRunner(verbosity=2).run(tests)","def RunTest(self):\n self.TestLs()\n self.TestTerminate()\n self.TestMultipleProcesses()","def runTest(self):\n unittest.main()\n ChoreTest.clean_up()","def run_test_suite(*args):\n test_args = list(args) or []\n execute_from_command_line([\"manage.py\", \"test\"] + test_args)","def make_all():\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n member[1](master=True)\n print('done!')","def make_all():\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n member[1](master=True)\n print('done!')","def test():\n import unittest\n tests = unittest \n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def run_main(): # pragma: no cover\n RunTestsCLI.run()","def test_generate_all_testing(self):\n pass","def test():\n with lcd(BASEDIR):\n local('virtenv/bin/coverage run runtests.py -v2')\n local('virtenv/bin/coverage report -m')","def run_tests(self, test_labels):\n import pytest\n\n argv = []\n if self.verbosity == 0:\n argv.append('--quiet')\n if self.verbosity == 2:\n argv.append('--verbose')\n if self.verbosity == 3:\n argv.append('-vv')\n if self.failfast:\n argv.append('--exitfirst')\n if self.keepdb:\n argv.append('--reuse-db')\n\n argv.extend(test_labels)\n return pytest.main(argv)","def test_all_envs(func):\n register_tests(func, [func.__name__ + '_emulator',\n func.__name__ + '_verilator'])","def run(self):\n if self.all:\n cmd = self.apply_options(self.test_all_cmd)\n self.call_and_exit(cmd)\n else:\n cmds = (self.apply_options(self.unit_test_cmd, (\"coverage\",)),)\n if self.coverage:\n cmds += (self.apply_options(self.coverage_cmd),)\n self.call_in_sequence(cmds)","def startTestRun(self):","def test_lint(self):\n l = self.l\n l.loadTestsFromTestCase\n l.loadTestsFromModule\n l.loadTestsFromName\n l.loadTestsFromNames","def test_script(self) -> None:\n main()","def run_tests(session):\n set_environment_variables(PYBAMM_ENV, session=session)\n session.run_always(\"pip\", \"install\", \"-e\", \".[all]\")\n if sys.platform == \"linux\" or sys.platform == \"darwin\":\n session.run_always(\"pip\", \"install\", \"-e\", \".[odes]\")\n session.run_always(\"pip\", \"install\", \"-e\", \".[jax]\")\n session.run(\"python\", \"run-tests.py\", \"--all\")","def test():\n tests = unittest.TestLoader().discover('project/tests', pattern='test*.py')\n result = unittest.TextTestRunner(verbosity=2).run(tests)\n if result.wasSuccessful():\n return 0\n sys.exit(result)","def test(test_names):\n import unittest\n if test_names:\n tests = unittest.TestLoader().loadTestsFromNames(test_names)\n else:\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def execute_tests():\n import django\n\n sys.exc_clear()\n\n os.environ[\"DJANGO_SETTINGS_MODULE\"] = \"django.conf.global_settings\"\n from django.conf import global_settings\n\n global_settings.INSTALLED_APPS = ()\n global_settings.MIDDLEWARE_CLASSES = ()\n global_settings.SECRET_KEY = \"not-very-secret\"\n\n global_settings.DATABASES = {\n 'default': {\n 'ENGINE': 'django.db.backends.sqlite3',\n }\n }\n\n # http://django.readthedocs.org/en/latest/releases/1.7.html#standalone-scripts\n if django.VERSION >= (1,7):\n django.setup()\n\n from django.test.utils import get_runner\n test_runner = get_runner(global_settings)\n\n test_runner = test_runner()\n failures = test_runner.run_tests(['s3cache'])\n sys.exit(failures)","def runTest(self):\n self.setUp()\n self.test_modul1()"],"string":"[\n \"def _run_local_tests(self, *args, **kwargs):\\n pass\",\n \"def runAll():\\n\\n loader = unittest.TestLoader()\\n test_dir = pkg_resources.resource_filename('frvcpy.test','.')\\n suite = loader.discover(test_dir)\\n\\n runner = unittest.TextTestRunner(verbosity=2)\\n runner.run(suite)\",\n \"def main():\\n run_test_all()\",\n \"def tests():\\n api.local('nosetests')\",\n \"def runalltests():\\n doctest.testmod()\",\n \"def run_test_suite():\\n local('. fabric_factory/ve/bin/activate; fabric_factory/src/project/manage.py test')\",\n \"def runTests(self):\\n \\n pass\",\n \"def run_all_tests():\\n remove_dbs()\\n run_training_tests()\\n run_custom_training_tests()\\n run_training_save_tests()\\n run_validation_tests()\\n run_feature_extraction_tests()\",\n \"def test(self):\\n for arch, python in self.python:\\n self.run(f\\\"{python} -m pytest\\\")\",\n \"def run_tests(self):\\n\\n self.manifest_path = os.path.join('tests',\\n 'remote',\\n 'manifest.ini')\\n TestRun.run_tests(self)\",\n \"def run_all_tests(self):\\n for index in range(len(self.__test_set_list)):\\n self.run_test(index)\",\n \"def run_all_unit_tests(cls):\\n suites_list = []\\n for test_class in cls.TESTS:\\n suite = unittest.TestLoader().loadTestsFromTestCase(test_class)\\n suites_list.append(suite)\\n result = unittest.TextTestRunner().run(unittest.TestSuite(suites_list))\\n if not result.wasSuccessful() or result.errors:\\n raise Exception(result)\",\n \"def local_test():\\n pass\",\n \"def run_tests(self):\\n\\n self.manifest_path = os.path.join('tests',\\n 'functional',\\n 'manifest.ini')\\n TestRun.run_tests(self)\",\n \"def test_all():\\n test_get_to()\\n test_error_type()\\n test_exchange()\\n print(\\\"All tests passed.\\\")\",\n \"def RunTestAll(ss):\\n ss.StopNow = False\\n ss.TestAll()\\n ss.Stopped()\",\n \"def run():\\n\\tsubsuite_list = []\\n\\tfor _, modname, _ in pkgutil.iter_modules(test.__path__):\\n\\t\\tif modname.startswith(\\\"test_\\\"):\\n\\t\\t\\tmodule = importlib.import_module('test.' + modname)\\n\\t\\t\\tsubsuite = unittest.TestLoader().loadTestsFromModule(module)\\n\\t\\t\\tsubsuite_list.append(subsuite)\\n\\tsuite = unittest.TestSuite(subsuite_list)\\n\\n\\tprint(\\\"Testing:\\\\n\\\")\\n\\tunittest.TextTestRunner(verbosity=2).run(suite)\",\n \"def runtests():\\n #- Load all TestCase classes from desistar/test/test_*.py\\n tests = desistar_test_suite()\\n #- Run them\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def run_tests():\\n testfiles = ['tests.test_overall']\\n exclude = ['__init__.py', 'test_overall.py']\\n for t in glob(pjoin('tests', '*.py')):\\n if True not in [t.endswith(ex) for ex in exclude]:\\n if basename(t).startswith('test_'):\\n testfiles.append('tests.%s' % splitext(basename(t))[0])\\n\\n suites = []\\n for file in testfiles:\\n __import__(file)\\n suites.append(sys.modules[file].suite)\\n\\n tests = unittest.TestSuite(suites)\\n runner = unittest.TextTestRunner(verbosity=2)\\n\\n # Disable logging output\\n logging.basicConfig(level=100)\\n logging.disable(100)\\n\\n result = runner.run(tests)\\n return result\",\n \"def run_tests():\\n fail = []\\n okay = []\\n for i in os.listdir(\\\".\\\"):\\n if i.find(\\\"_test_\\\") > -1 and i.endswith(\\\".py\\\"):\\n if 0 != subprocess.call(\\\"python \\\" + i, shell=True):\\n fail.append(i)\\n else:\\n okay.append(i)\\n if fail:\\n print(\\\"[ERROR] The following %u tests failed: %r\\\" % (len(fail), fail))\\n return False\\n print(\\\"[DONE] All %u tests completely successfully!\\\" % (len(okay)))\\n return True\",\n \"def run_all_tests(self) -> None:\\n self.run_trt_precision_tests()\\n logging.info(\\\"Check analysis result at: %s\\\", self._output_dir)\",\n \"def tests():\",\n \"def test():\\n for cmd in [\\n \\\"pytest --verbose --cov pike/ --cov-report term --cov-report html tests/\\\",\\n ]:\\n _run_in_venv(shlex.split(cmd))\\n for linter in [[\\\"black\\\", \\\"--check\\\"], [\\\"flake8\\\"], [\\\"isort\\\", \\\"--check\\\"]]:\\n _run_in_venv(linter + TEST_FILES)\\n\\n _run_in_venv(\\n [\\\"mypy\\\", \\\"pike/\\\", \\\"tests/\\\", \\\"setup.py\\\", \\\"pikefile.py\\\", \\\"--show-error-codes\\\"]\\n )\\n _run_in_venv([\\\"mypy\\\", \\\"examples/\\\"])\\n _run_in_venv([\\\"bandit\\\", \\\"-r\\\", \\\"pike/\\\"])\",\n \"def _run_ci_test():\\n _run_install(False)\\n _run_coverage_html(False)\\n _run_typecheck_xml(False)\\n _run_lint(True)\",\n \"def runtests(ctx):\\n run('pytest -s tests', pty=pty_available)\\n run('flake8 --ignore E265,E266,E501 --exclude src, lib', pty=pty_available)\",\n \"def doAllTests(self):\\n # Initial offset\\n self.getAlertsFile()\\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\\n\\n # Do all tests\\n # As the socket is not persistent, client side attacks have to be done before all tests\\n for module in self.modules:\\n # Test is performed only if selected in config.cfg\\n if self.config.get('TESTS', module[1]) == '1':\\n print \\\"\\\\n%s\\\\n------------\\\" % module[0].upper()\\n if module[1]=='clientSideAttacks':\\n self.doClientSideAttacksTest( clientSideAttacks.ClientSideAttacks(self._target).getPayloads() )\\n# elif module[1]=='multipleFailedLogins':\\n# self.doMultipleFailedLoginsTest( multipleFailedLogins.MultipleFailedLogins(self._target).getPayloads() )\\n else:\\n self.doTest( module[1], eval( ('%s.%s'+'(self._target,self._cnf).getPayloads()') % (module[1], module[1][:1].upper()+module[1][1:]) ) )\\n\\n # Done!\\n print \\\"\\\\n\\\\n-----------------------\\\"\\n print \\\"DONE. Check the report.\\\"\\n print \\\"-----------------------\\\\n\\\"\",\n \"def main():\\n # add all new test suites per test module here\\n suite_date = test_date.suite()\\n suite_ng = test_ng.suite()\\n suite_page = test_page.suite()\\n suite_container = test_container.suite()\\n\\n # add the suite to be tested here\\n alltests = unittest.TestSuite((suite_date,\\n suite_ng,\\n suite_page,\\n suite_container))\\n\\n # run the suite\\n runner = unittest.TextTestRunner()\\n runner.run(alltests)\",\n \"def __main() :\\n launchTests()\",\n \"def run_tests(tests):\\n return [test(t) for t in tests]\",\n \"def runAllTests():\\n\\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\\n\\tnTests = ttr.testsRun + len(ttr.skipped)\\n\\tprint(\\\"Report:\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.failures)) + \\\"/\\\" + str(nTests) + \\\" failed\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.errors)) + \\\"/\\\" + str(nTests) + \\\" errors\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.skipped)) + \\\"/\\\" + str(nTests) + \\\" skipped\\\")\",\n \"def run_tests(self):\\n\\n self.manifest_path = os.path.join('tests',\\n 'l10n',\\n 'manifest.ini')\\n TestRun.run_tests(self)\",\n \"def run_tests(self):\\n raise NotImplementedError\",\n \"def _run_tests(self):\\n for pyunit_testcase in self.cfg.testcases:\\n yield self._run_testsuite(pyunit_testcase)\",\n \"def test():\\n import unittest\\n\\n tests = unittest.TestLoader().discover(\\\"tests\\\")\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def collectTests(self, global_ctx):\\n pass\",\n \"def run_tests():\\n test_command = \\\"pytest -s \\\" + os.path.join(root_path, \\\"cases\\\", \\\"test_cases.py::TestCases::test_cases\\\") + \\\" --html=\\\" + os.path.join(root_path, \\\"reports\\\", \\\"qa_testing_report.html\\\")\\n\\n subprocess.run(test_command, shell=True)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def tests(context):\\n black(context)\\n isort(context)\\n flake8(context)\\n pylint(context)\\n yamllint(context)\\n pydocstyle(context)\\n bandit(context)\\n pytest(context)\\n\\n print(\\\"All tests have passed!\\\")\",\n \"def test_all():\\n test_prepare_text()\\n test_end_chat()\\n test_choose_author()\\n test_choose_book()\",\n \"def RunAll():\\n testfunctions = []\\n for name, obj in inspect.getmembers(sys.modules[__name__]):\\n if inspect.isfunction(obj) and name != 'RunAll':\\n testfunctions.append(obj)\\n\\n # run all the functions\\n for f in testfunctions:\\n print('Running %s' % str(f))\\n f()\",\n \"def runtest(self):\",\n \"def run_all(self):\\n failures, errors = [], []\\n\\n # Run each test case registered with us and agglomerate the results.\\n for case_ in self.cases:\\n case_.run()\\n update_results(failures, errors, case_)\\n\\n # Display our results.\\n print_errors(errors)\\n print_failures(failures)\\n print_overview(errors, failures)\\n\\n # Exit with 0 if all tests passed, >0 otherwise.\\n sys.exit(len(failures) + len(errors))\",\n \"def run_all_tests():\\n successes = 0\\n testsrun = 0\\n testsdir = tests_dirpath()\\n for test in os.listdir(testsdir):\\n path = os.path.join(testsdir, test)\\n if os.path.isdir(path):\\n testsrun += 1\\n if run_test(path):\\n successes += 1\\n print(\\\"--- %d/%d TESTS PASSED ---\\\" % (successes, testsrun))\\n return successes == testsrun\",\n \"def unittest():\\n from a6test import test_all\\n test_all()\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def runtests():\\r\\n\\r\\n app_abspath = os.path.dirname(os.path.dirname(__file__))\\r\\n models_abspath = os.path.join(app_abspath, 'models.py')\\r\\n models_exists = os.path.isfile(models_abspath)\\r\\n urls_abspath = os.path.join(app_abspath, 'urls.py')\\r\\n urls_exists = os.path.isfile(urls_abspath)\\r\\n views_abspath = os.path.join(app_abspath, 'views')\\r\\n views_exists = os.path.isdir(views_abspath)\\r\\n tpls_abspath = os.path.join(app_abspath, 'templates')\\r\\n tpls_exists = os.path.isdir(tpls_abspath)\\r\\n\\r\\n for f in [models_abspath, urls_abspath]:\\r\\n if os.path.isfile(f):\\r\\n subprocess.call('cp {} {}.orig'.format(f, f), shell=True)\\r\\n\\r\\n if views_exists:\\r\\n subprocess.call('cp -r {} {}.orig'.format(views_abspath, views_abspath), shell=True)\\r\\n\\r\\n if tpls_exists:\\r\\n subprocess.call('cp -r {} {}.orig'.format(tpls_abspath, tpls_abspath), shell=True)\\r\\n\\r\\n overwrite_project_language('ja')\\r\\n subprocess.call('python manage.py generatescaffold test_app I18nModel title:string', shell=True)\\r\\n time.sleep(1)\\r\\n overwrite_project_language('en-us')\\r\\n time.sleep(1)\\r\\n\\r\\n subprocess.call('python manage.py generatescaffold test_app GeneratedNoTimestampModel title:string description:text --no-timestamps', shell=True)\\r\\n time.sleep(2) # Give time for Django's AppCache to clear\\r\\n\\r\\n subprocess.call('python manage.py generatescaffold test_app GeneratedModel title:string description:text', shell=True)\\r\\n\\r\\n test_status = subprocess.call('python manage.py test --with-selenium --with-selenium-fixtures --with-cherrypyliveserver --noinput', shell=True)\\r\\n\\r\\n if models_exists:\\r\\n subprocess.call('mv {}.orig {}'.format(models_abspath, models_abspath), shell=True)\\r\\n else:\\r\\n subprocess.call('rm {}'.format(models_abspath), shell=True)\\r\\n\\r\\n if urls_exists:\\r\\n subprocess.call('mv {}.orig {}'.format(urls_abspath, urls_abspath), shell=True)\\r\\n else:\\r\\n subprocess.call('rm {}'.format(urls_abspath), shell=True)\\r\\n\\r\\n if views_exists:\\r\\n subprocess.call('rm -rf {}'.format(views_abspath), shell=True)\\r\\n subprocess.call('mv {}.orig {}'.format(views_abspath, views_abspath), shell=True)\\r\\n else:\\r\\n subprocess.call('rm -rf {}'.format(views_abspath), shell=True)\\r\\n\\r\\n if tpls_exists:\\r\\n subprocess.call('rm -rf {}'.format(tpls_abspath), shell=True)\\r\\n subprocess.call('mv {}.orig {}'.format(tpls_abspath, tpls_abspath), shell=True)\\r\\n else:\\r\\n subprocess.call('rm -rf {}'.format(tpls_abspath), shell=True)\\r\\n\\r\\n subprocess.call('rm {}/*.pyc'.format(app_abspath), shell=True)\\r\\n\\r\\n sys.exit(test_status)\",\n \"def django_run_tests():\\r\\n \\r\\n settings_py, manage_py = _CDjangoPluginActivator._instance._FindKeyFiles()\\r\\n loc = location.CreateFromName(settings_py)\\r\\n cmd = 'run_test_files(locs=\\\"%s\\\")' % settings_py\\r\\n wingapi.gApplication.ExecuteCommand(cmd)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover(tests)\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def run_tests():\\n argument_parser = ArgumentParser(description=\\\"Run all tests for {{project name}}\\\")\\n #TODO add some configuration here\\n\\n settings.configure(**{\\n \\\"DATABASE_ENGINE\\\" : \\\"django.db.backends.sqlite3\\\",\\n \\\"DATABASE_NAME\\\" : \\\"sqlite://:memory:\\\",\\n \\\"ROOT_URLCONF\\\" : \\\"tests.urls\\\",\\n \\\"TEMPLATE_LOADERS\\\" : (\\n \\\"django.template.loaders.filesystem.load_template_source\\\",\\n \\\"django.template.loaders.app_directory.load_template_source\\\",\\n ),\\n \\\"TEMPLATE_DIRS\\\" : (\\n path(__file__).dirname() / 'templates',\\n ),\\n \\\"INSTALLED_APPS\\\" : (\\n 'django.contrib.admin',\\n 'django.contrib.auth',\\n 'django.contrib.contenttypes',\\n 'django.contrib.sessions',\\n 'django.contrib.sites',\\n '{{ project_name }},\\n ),\\n })\\n call_command(\\\"test\\\")\",\n \"def test():\\n import unittest\\n testmodules = [\\n 'bettermathlib_tests',\\n 'randomwebapp_tests',\\n ]\\n suite = unittest.TestSuite()\\n for t in testmodules:\\n suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))\\n unittest.TextTestRunner(verbosity=2).run(suite)\",\n \"def main():\\n fix_sys_path()\\n result = unittest.TextTestRunner(verbosity=2).run(createTestSuite())\\n\\n if result.testsRun != EXPECTED_TEST_COUNT:\\n raise Exception(\\n 'Expected %s tests to be run, not %s.' % (EXPECTED_TEST_COUNT, result.testsRun))\\n\\n if len(result.errors) != 0 or len(result.failures) != 0:\\n raise Exception(\\n \\\"Functional test suite failed: %s errors, %s failures of %s tests run.\\\" % (\\n len(result.errors), len(result.failures), result.testsRun))\",\n \"def test():\\n\\n tests = unittest.TestLoader().discover('api/tests/', pattern='*/test_*.py')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def run_tests(self):\\n manifest = manifestparser.TestManifest(\\n manifests=[os.path.join(self.repository_path, self.manifest_path)],\\n strict=False)\\n\\n tests = manifest.active_tests(**mozinfo.info)\\n self._mozmill.run(tests, self.options.restart)\\n\\n # Whenever a test fails it has to be marked, so we quit with the correct exit code\\n self.last_failed_tests = self.last_failed_tests or self._mozmill.results.fails\\n\\n self.testrun_index += 1\",\n \"def do_test(self):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\tif not self.build['dotest']:\\n\\t\\t\\tself.log('Tests configured off, not running',level=logging.DEBUG)\\n\\t\\t\\treturn\\n\\t\\t# Test in reverse order\\n\\t\\tself.log('PHASE: test', level=logging.DEBUG)\\n\\t\\tself.stop_all()\\n\\t\\tself.start_all()\\n\\t\\tfor module_id in self.module_ids(rev=True):\\n\\t\\t\\t# Only test if it's installed.\\n\\t\\t\\tif self.is_installed(self.shutit_map[module_id]):\\n\\t\\t\\t\\tself.log('RUNNING TEST ON: ' + module_id, level=logging.DEBUG)\\n\\t\\t\\t\\tself.login(prompt_prefix=module_id,command=shutit_global.shutit_global_object.bash_startup_command,echo=False)\\n\\t\\t\\t\\tif not self.shutit_map[module_id].test(self):\\n\\t\\t\\t\\t\\tself.fail(module_id + ' failed on test', shutit_pexpect_child=self.get_shutit_pexpect_session_from_id('target_child').pexpect_child) # pragma: no cover\\n\\t\\t\\t\\tself.logout(echo=False)\",\n \"def run_tests(virtual_env):\\n signal.signal(signal.SIGINT, signal.SIG_IGN)\\n args = [\\n 'python',\\n 'setup.py',\\n 'nosetests',\\n '--with-coverage',\\n '--with-xunit',\\n ]\\n subprocess.call(args, cwd=abspath(join(HOLLAND_ROOT, 'holland-core')), env=virtual_env)\\n subprocess.call(['coverage', 'xml'], cwd=abspath(join(HOLLAND_ROOT, 'holland-core')), env=virtual_env)\\n for plugin_dir in open(join(HOLLAND_ROOT, 'plugins', 'ACTIVE')):\\n plugin_dir = plugin_dir.rstrip()\\n plugin_path = join(HOLLAND_ROOT, 'plugins', plugin_dir)\\n subprocess.call(args, cwd=plugin_path, env=virtual_env)\\n subprocess.call(['coverage', 'xml'], cwd=plugin_path, env=virtual_env)\\n for addon_dir in open(join(HOLLAND_ROOT, 'addons', 'ACTIVE')):\\n addon_dir = addon_dir.rstrip()\\n addon_path = join(HOLLAND_ROOT, 'addons', addon_dir)\\n subprocess.call(args, cwd=addon_path, env=virtual_env)\\n subprocess.call(['coverage', 'xml'], cwd=plugin_path, env=virtual_env)\\n #return subprocess.call(args, env=virtual_env)\",\n \"def run_tests(self):\\n # Charm does not defer hooks so that test is not included.\\n # Trigger a package change which requires a restart\\n self.run_package_change_test(\\n 'ovn-central',\\n 'ovn-central')\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n\\n tests = unittest.TestLoader().discover(\\\"tests\\\")\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def execute(self):\\n for test in self.tests:\\n test.execute()\\n self.logger.dump()\\n print(\\\"Finished!\\\")\",\n \"def test():\\r\\n import unittest\\r\\n tests = unittest.TestLoader().discover('tests')\\r\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\r\\n import unittest\\r\\n tests = unittest.TestLoader().discover('tests')\\r\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\r\\n import unittest\\r\\n tests=unittest.TestLoader().discover('tests')\\r\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def run_all_unit_tests():\\n original = verify.parse_content\\n try:\\n verify.parse_content = parse_string_in_scope\\n\\n test_list_of()\\n\\n test_activity_multiple_choice()\\n test_activity_free_text()\\n test_activity_multiple_choice_group()\\n test_activity_ast()\\n\\n test_assessment()\\n test_assessment_ast()\\n\\n # test existing verifier using parsing instead of exec/compile\\n verify.test_sample_assets()\\n finally:\\n verify.parse_content = original\",\n \"def test():\\n loader = unittest.TestLoader()\\n suite = loader.discover(os.path.dirname(__file__))\\n runner = unittest.TextTestRunner()\\n runner.run(suite)\",\n \"def test():\\n import unittest\\n\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n import unittest\\n import tests\\n tests = unittest.TestLoader().discover('tests', pattern='*tests.py')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def RunTest(self):\\n self.TestLs()\\n self.TestTerminate()\\n self.TestMultipleProcesses()\",\n \"def runTest(self):\\n unittest.main()\\n ChoreTest.clean_up()\",\n \"def run_test_suite(*args):\\n test_args = list(args) or []\\n execute_from_command_line([\\\"manage.py\\\", \\\"test\\\"] + test_args)\",\n \"def make_all():\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n member[1](master=True)\\n print('done!')\",\n \"def make_all():\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n member[1](master=True)\\n print('done!')\",\n \"def test():\\n import unittest\\n tests = unittest \\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def run_main(): # pragma: no cover\\n RunTestsCLI.run()\",\n \"def test_generate_all_testing(self):\\n pass\",\n \"def test():\\n with lcd(BASEDIR):\\n local('virtenv/bin/coverage run runtests.py -v2')\\n local('virtenv/bin/coverage report -m')\",\n \"def run_tests(self, test_labels):\\n import pytest\\n\\n argv = []\\n if self.verbosity == 0:\\n argv.append('--quiet')\\n if self.verbosity == 2:\\n argv.append('--verbose')\\n if self.verbosity == 3:\\n argv.append('-vv')\\n if self.failfast:\\n argv.append('--exitfirst')\\n if self.keepdb:\\n argv.append('--reuse-db')\\n\\n argv.extend(test_labels)\\n return pytest.main(argv)\",\n \"def test_all_envs(func):\\n register_tests(func, [func.__name__ + '_emulator',\\n func.__name__ + '_verilator'])\",\n \"def run(self):\\n if self.all:\\n cmd = self.apply_options(self.test_all_cmd)\\n self.call_and_exit(cmd)\\n else:\\n cmds = (self.apply_options(self.unit_test_cmd, (\\\"coverage\\\",)),)\\n if self.coverage:\\n cmds += (self.apply_options(self.coverage_cmd),)\\n self.call_in_sequence(cmds)\",\n \"def startTestRun(self):\",\n \"def test_lint(self):\\n l = self.l\\n l.loadTestsFromTestCase\\n l.loadTestsFromModule\\n l.loadTestsFromName\\n l.loadTestsFromNames\",\n \"def test_script(self) -> None:\\n main()\",\n \"def run_tests(session):\\n set_environment_variables(PYBAMM_ENV, session=session)\\n session.run_always(\\\"pip\\\", \\\"install\\\", \\\"-e\\\", \\\".[all]\\\")\\n if sys.platform == \\\"linux\\\" or sys.platform == \\\"darwin\\\":\\n session.run_always(\\\"pip\\\", \\\"install\\\", \\\"-e\\\", \\\".[odes]\\\")\\n session.run_always(\\\"pip\\\", \\\"install\\\", \\\"-e\\\", \\\".[jax]\\\")\\n session.run(\\\"python\\\", \\\"run-tests.py\\\", \\\"--all\\\")\",\n \"def test():\\n tests = unittest.TestLoader().discover('project/tests', pattern='test*.py')\\n result = unittest.TextTestRunner(verbosity=2).run(tests)\\n if result.wasSuccessful():\\n return 0\\n sys.exit(result)\",\n \"def test(test_names):\\n import unittest\\n if test_names:\\n tests = unittest.TestLoader().loadTestsFromNames(test_names)\\n else:\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def execute_tests():\\n import django\\n\\n sys.exc_clear()\\n\\n os.environ[\\\"DJANGO_SETTINGS_MODULE\\\"] = \\\"django.conf.global_settings\\\"\\n from django.conf import global_settings\\n\\n global_settings.INSTALLED_APPS = ()\\n global_settings.MIDDLEWARE_CLASSES = ()\\n global_settings.SECRET_KEY = \\\"not-very-secret\\\"\\n\\n global_settings.DATABASES = {\\n 'default': {\\n 'ENGINE': 'django.db.backends.sqlite3',\\n }\\n }\\n\\n # http://django.readthedocs.org/en/latest/releases/1.7.html#standalone-scripts\\n if django.VERSION >= (1,7):\\n django.setup()\\n\\n from django.test.utils import get_runner\\n test_runner = get_runner(global_settings)\\n\\n test_runner = test_runner()\\n failures = test_runner.run_tests(['s3cache'])\\n sys.exit(failures)\",\n \"def runTest(self):\\n self.setUp()\\n self.test_modul1()\"\n]"},"negative_scores":{"kind":"list like","value":["0.8297117","0.7959936","0.7950929","0.7797158","0.768714","0.766804","0.76199144","0.75607073","0.7456279","0.744708","0.7380929","0.7380103","0.72950643","0.7281221","0.727362","0.7181298","0.71580607","0.7139827","0.7125284","0.70671266","0.7064775","0.7064144","0.7061675","0.70427084","0.7038519","0.70306754","0.700941","0.7003991","0.69682187","0.6947895","0.6941255","0.69383717","0.69304764","0.6918372","0.6917669","0.6915974","0.68886817","0.68886817","0.68886817","0.68653417","0.68638426","0.6857378","0.6847217","0.68454874","0.6836972","0.683234","0.68306434","0.6830312","0.68217397","0.67976826","0.6779681","0.6779171","0.6775913","0.6768906","0.6766041","0.6759414","0.67546356","0.6753306","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6749121","0.6745705","0.6733487","0.67334163","0.67334163","0.67249024","0.6722685","0.67225426","0.6721593","0.67075443","0.67040694","0.6702716","0.6687353","0.6657964","0.6657964","0.66578114","0.6655818","0.66553026","0.66426146","0.6637389","0.6626522","0.6612849","0.6580203","0.6577367","0.657586","0.65680844","0.655509","0.65472496","0.65414315","0.6520224"],"string":"[\n \"0.8297117\",\n \"0.7959936\",\n \"0.7950929\",\n \"0.7797158\",\n \"0.768714\",\n \"0.766804\",\n \"0.76199144\",\n \"0.75607073\",\n \"0.7456279\",\n \"0.744708\",\n \"0.7380929\",\n \"0.7380103\",\n \"0.72950643\",\n \"0.7281221\",\n \"0.727362\",\n \"0.7181298\",\n \"0.71580607\",\n \"0.7139827\",\n \"0.7125284\",\n \"0.70671266\",\n \"0.7064775\",\n \"0.7064144\",\n \"0.7061675\",\n \"0.70427084\",\n \"0.7038519\",\n \"0.70306754\",\n \"0.700941\",\n \"0.7003991\",\n \"0.69682187\",\n \"0.6947895\",\n \"0.6941255\",\n \"0.69383717\",\n \"0.69304764\",\n \"0.6918372\",\n \"0.6917669\",\n \"0.6915974\",\n \"0.68886817\",\n \"0.68886817\",\n \"0.68886817\",\n \"0.68653417\",\n \"0.68638426\",\n \"0.6857378\",\n \"0.6847217\",\n \"0.68454874\",\n \"0.6836972\",\n \"0.683234\",\n \"0.68306434\",\n \"0.6830312\",\n \"0.68217397\",\n \"0.67976826\",\n \"0.6779681\",\n \"0.6779171\",\n \"0.6775913\",\n \"0.6768906\",\n \"0.6766041\",\n \"0.6759414\",\n \"0.67546356\",\n \"0.6753306\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6749121\",\n \"0.6745705\",\n \"0.6733487\",\n \"0.67334163\",\n \"0.67334163\",\n \"0.67249024\",\n \"0.6722685\",\n \"0.67225426\",\n \"0.6721593\",\n \"0.67075443\",\n \"0.67040694\",\n \"0.6702716\",\n \"0.6687353\",\n \"0.6657964\",\n \"0.6657964\",\n \"0.66578114\",\n \"0.6655818\",\n \"0.66553026\",\n \"0.66426146\",\n \"0.6637389\",\n \"0.6626522\",\n \"0.6612849\",\n \"0.6580203\",\n \"0.6577367\",\n \"0.657586\",\n \"0.65680844\",\n \"0.655509\",\n \"0.65472496\",\n \"0.65414315\",\n \"0.6520224\"\n]"},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":1692,"cells":{"query":{"kind":"string","value":"Run all network tests"},"document":{"kind":"string","value":"def net():\n suite = ServiceTestSuite()\n suite.addTest(unittest.makeSuite(AmazonTestCase, 'test_net'))\n return suite"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_all():\n test_get_to()\n test_error_type()\n test_exchange()\n print(\"All tests passed.\")","def run_all_tests():\n remove_dbs()\n run_training_tests()\n run_custom_training_tests()\n run_training_save_tests()\n run_validation_tests()\n run_feature_extraction_tests()","def runTests(self):\n \n pass","def runAll():\n\n loader = unittest.TestLoader()\n test_dir = pkg_resources.resource_filename('frvcpy.test','.')\n suite = loader.discover(test_dir)\n\n runner = unittest.TextTestRunner(verbosity=2)\n runner.run(suite)","def main():\n run_test_all()","def doAllTests(self):\n # Initial offset\n self.getAlertsFile()\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\n\n # Do all tests\n # As the socket is not persistent, client side attacks have to be done before all tests\n for module in self.modules:\n # Test is performed only if selected in config.cfg\n if self.config.get('TESTS', module[1]) == '1':\n print \"\\n%s\\n------------\" % module[0].upper()\n if module[1]=='clientSideAttacks':\n self.doClientSideAttacksTest( clientSideAttacks.ClientSideAttacks(self._target).getPayloads() )\n# elif module[1]=='multipleFailedLogins':\n# self.doMultipleFailedLoginsTest( multipleFailedLogins.MultipleFailedLogins(self._target).getPayloads() )\n else:\n self.doTest( module[1], eval( ('%s.%s'+'(self._target,self._cnf).getPayloads()') % (module[1], module[1][:1].upper()+module[1][1:]) ) )\n\n # Done!\n print \"\\n\\n-----------------------\"\n print \"DONE. Check the report.\"\n print \"-----------------------\\n\"","def tests():\n api.local('nosetests')","def runalltests():\n doctest.testmod()","def run_tests():\n \n test_constructor_positive()\n test_constructor_negative()\n test_game_move_positive()\n test_game_move_negative()\n test_game_move_edge()\n print(\"Congratulations ! You passed all the game test cases.\")","def run_custom_training_tests():\n test_custom_training()\n test_custom_distributed_training()\n test_custom_multimodel_training()\n test_custom_distributed_multimodel_training()","def test_run():\n # Only few steps for test\n timesteps = 128\n\n # Compute all sub testing conf\n envs = ['CartPole-v0']\n ml_platforms = ['torch', 'tf']\n agents = ['dqn', 'a2c']\n\n test_combinations = list(it.product(\n envs,\n ml_platforms,\n agents\n )\n )\n\n # Finally test them all\n for conf in test_combinations:\n env_str, ml_platform_str, agent_str = conf\n run(\n agent_str,\n ml_platform_str,\n env_str,\n 'dense',\n timesteps,\n './target/')","def run_all_tests(self):\n for index in range(len(self.__test_set_list)):\n self.run_test(index)","def test_get_networks(self):\n pass","def test_core(c):\n def test_python(c, filename):\n \"\"\"Run a single python test file in tests/python.\"\"\"\n test_dir = 'tests/python'\n filepath = '{}/{}'.format(test_dir, filename)\n\n print('Restarting network before executing test {}'.format(filepath))\n rm_network(c)\n start_core(c)\n start_horizon(c)\n network(c)\n\n with c.cd(test_dir):\n print('Executing test {}'.format(filepath))\n c.run('pipenv run python {filename} \"{passphrase}\" {whitelist_seed}'.format(\n filename=filename,\n passphrase=PASSPHRASE,\n whitelist_seed=WHITELIST_SEED))\n\n test_python(c, 'test_base_reserve.py')\n test_python(c, 'test_tx_order_by_fee.py')\n test_python(c, 'test_tx_order_by_whitelist.py')\n test_python(c, 'test_tx_priority_for_whitelist_holder.py')\n test_python(c, 'test_whitelist_affected_on_next_ledger.py')\n\n # XXX obsolete\n # see source file for more information\n # test_python(c, 'test_multiple_cores.py')","def main():\r\n test = TesterNeighbour()\r\n test.setUp()\r\n test.test_result_n()\r\n print(\"result_of_algorithm_test - passed\")","def run_tests(self):\n raise NotImplementedError","def tests():","def main():\n test_network_connection()\n parser()","def RunTest(self):\n self.TestLs()\n self.TestTerminate()\n self.TestMultipleProcesses()","def main():\n test_runner = TestRunner(\n FLAGS.workspace, FLAGS.bench_home, imagenet_dir=FLAGS.train_data_dir)\n test_runner.run_tests(FLAGS.test_list.split(','))","def run_all(self):\n failures, errors = [], []\n\n # Run each test case registered with us and agglomerate the results.\n for case_ in self.cases:\n case_.run()\n update_results(failures, errors, case_)\n\n # Display our results.\n print_errors(errors)\n print_failures(failures)\n print_overview(errors, failures)\n\n # Exit with 0 if all tests passed, >0 otherwise.\n sys.exit(len(failures) + len(errors))","def run_all_unit_tests(cls):\n suites_list = []\n for test_class in cls.TESTS:\n suite = unittest.TestLoader().loadTestsFromTestCase(test_class)\n suites_list.append(suite)\n result = unittest.TextTestRunner().run(unittest.TestSuite(suites_list))\n if not result.wasSuccessful() or result.errors:\n raise Exception(result)","def RunTestAll(ss):\n ss.StopNow = False\n ss.TestAll()\n ss.Stopped()","def run_test_cases(self):\n count = 1\n for test_case in self.test_cases:\n print(\"Running test case #%d\" % count)\n if test_case.name == 'RouteDistance':\n distance = self.get_distance_for_route(test_case.args)\n print('%s distance: %s' % (test_case.args, distance))\n elif test_case.name == 'RouteShortest':\n args = test_case.args.split('|')\n shortest_distance = self.find_shortest_path_between_cities(args[0], args[1])\n print(\"Shortest distance between %s and %s: %d\" % (args[0], args[1], shortest_distance))\n elif test_case.name == 'RouteLessThanHops':\n args = test_case.args.split('|')\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]))\n print('Paths between %s and %s with hops less than or equal to %d: %d (%s)' % (\n args[0], args[1], int(args[2]), len(paths), paths\n ))\n elif test_case.name == 'RouteEqualHops':\n args = test_case.args.split('|')\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]), equal=True)\n print('Paths between %s and %s with hops equal to %d: %d (%s)' % (\n args[0], args[1], int(args[2]), len(paths), paths\n ))\n elif test_case.name == 'RouteLessThanDistance':\n args = test_case.args.split('|')\n paths = self.trips_distance_constraint_bfs(args[0], args[1], int(args[2]))\n print('Paths between %s and %s with distance less than %d: %d (%s)' % (\n args[0], args[1], int(args[2]), len(paths), paths\n ))\n else:\n raise Exception('Unknown test case: %s' % test_case.name)\n count += 1\n print()","def run_all_tests(self) -> None:\n self.run_trt_precision_tests()\n logging.info(\"Check analysis result at: %s\", self._output_dir)","def test_add_network(self):\n pass","def runtest(self):","def run(self):\n if self.all:\n cmd = self.apply_options(self.test_all_cmd)\n self.call_and_exit(cmd)\n else:\n cmds = (self.apply_options(self.unit_test_cmd, (\"coverage\",)),)\n if self.coverage:\n cmds += (self.apply_options(self.coverage_cmd),)\n self.call_in_sequence(cmds)","def main(tests, root_uri, verbose):\n if verbose:\n rv_config.set_verbosity(verbosity=Verbosity.DEBUG)\n\n if len(tests) == 0:\n # no tests specified, so run all\n tests = list(ALL_TESTS.keys())\n else:\n # run all tests that start with the given string e.g \"chip\" will match\n # both \"chip_classification.basic\" and \"chip_classification.nochip\"\n _tests = []\n for t in tests:\n t = t.strip().lower()\n matching_tests = [k for k in ALL_TESTS.keys() if k.startswith(t)]\n _tests.extend(matching_tests)\n if len(matching_tests) == 0:\n console_error(\n f'{t} does not match any valid tests. Valid tests are: ')\n console_error(pformat(list(ALL_TESTS.keys())))\n continue\n tests = _tests\n\n console_info('The following tests will be run:')\n console_info(pformat(tests, compact=False))\n\n with get_tmp_dir() as tmp_dir:\n if root_uri:\n tmp_dir = root_uri\n\n num_failed = 0\n errors = {}\n for test_id in tests:\n test_cfg = ALL_TESTS[test_id]\n errors[test_id] = run_test(test_id, test_cfg, tmp_dir)\n if len(errors[test_id]) > 0:\n num_failed += 1\n\n for error in errors[test_id]:\n console_error(str(error))\n\n for test_id in tests:\n if test_id not in errors:\n continue\n if len(errors[test_id]) == 0:\n console_success(f'{test_id}: test passed!', bold=True)\n else:\n console_error(f'{test_id}: test failed!', bold=True)\n\n if num_failed > 0:\n console_error(\n f'Tests passed: {len(tests) - num_failed} of {len(tests)}')\n console_error('Error counts:')\n console_error(pformat({k: len(es) for k, es in errors.items()}))\n exit(1)","def run():\n\tsubsuite_list = []\n\tfor _, modname, _ in pkgutil.iter_modules(test.__path__):\n\t\tif modname.startswith(\"test_\"):\n\t\t\tmodule = importlib.import_module('test.' + modname)\n\t\t\tsubsuite = unittest.TestLoader().loadTestsFromModule(module)\n\t\t\tsubsuite_list.append(subsuite)\n\tsuite = unittest.TestSuite(subsuite_list)\n\n\tprint(\"Testing:\\n\")\n\tunittest.TextTestRunner(verbosity=2).run(suite)","def test_generate_all_testing(self):\n pass","def train(self, iterations=1):\n for _ in range(iterations):\n self.trainer.train()\n self.test_network()","def runTest(self):\n self.setUp()\n self.test_NeuroPath1()","def run_tests(self):\n setup_layers = {}\n layers_to_run = list(self.ordered_layers())\n should_resume = False\n\n while layers_to_run:\n layer_name, layer, tests = layers_to_run[0]\n for feature in self.features:\n feature.layer_setup(layer)\n try:\n self.ran += run_layer(self.options, layer_name, layer, tests,\n setup_layers, self.failures, self.errors,\n self.skipped, self.import_errors)\n except zope.testrunner.interfaces.EndRun:\n self.failed = True\n break\n except CanNotTearDown:\n if not self.options.resume_layer:\n should_resume = True\n break\n\n layers_to_run.pop(0)\n if self.options.processes > 1:\n should_resume = True\n break\n\n if self.options.stop_on_error and (self.failures or self.errors):\n break\n\n if should_resume:\n if layers_to_run:\n self.ran += resume_tests(\n self.script_parts, self.options, self.features,\n layers_to_run, self.failures, self.errors,\n self.skipped, self.cwd)\n\n if setup_layers:\n if self.options.resume_layer is None:\n self.options.output.info(\"Tearing down left over layers:\")\n tear_down_unneeded(\n self.options, (), setup_layers, self.errors, optional=True)\n\n self.failed = bool(self.import_errors or self.failures or self.errors)","def main():\n run_test_summary1a()\n run_test_summary1c()\n run_test_summary1c()","def runAllTests():\n\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\n\tnTests = ttr.testsRun + len(ttr.skipped)\n\tprint(\"Report:\")\n\tprint(\"\\t\" + str(len(ttr.failures)) + \"/\" + str(nTests) + \" failed\")\n\tprint(\"\\t\" + str(len(ttr.errors)) + \"/\" + str(nTests) + \" errors\")\n\tprint(\"\\t\" + str(len(ttr.skipped)) + \"/\" + str(nTests) + \" skipped\")","def __main() :\n launchTests()","def test_all():\n test_prepare_text()\n test_end_chat()\n test_choose_author()\n test_choose_book()","def runtests():\n #- Load all TestCase classes from desistar/test/test_*.py\n tests = desistar_test_suite()\n #- Run them\n unittest.TextTestRunner(verbosity=2).run(tests)","def run_tests():\n good_car = UnreliableCar(\"Good Car\", 100, 90)\n bad_car = UnreliableCar(\"Bad Car\", 100, 10)\n\n for i in range(1, 15):\n print(\"Attempting to drive {}km:\".format(i))\n print(\"{:12} drove {:2}km\".format(good_car.name, good_car.drive(i)))\n print(\"{:12} drove {:2}km\".format(bad_car.name, bad_car.drive(i)))\n\n \"\"\"final states of the cars\"\"\"\n print(good_car)\n print(bad_car)","def run_tests(self):\n\n self.manifest_path = os.path.join('tests',\n 'remote',\n 'manifest.ini')\n TestRun.run_tests(self)","def test_routers(self):\n if self.output_file == '':\n self.run_suite()\n else:\n with open(self.output_file, \"w\") as fp:\n self.run_suite(fp)","def init(self):\n \n self._nc_session = TestBedTests.TBNetconfSession(self.log, self.loop)\n self._nc_proxy = TestBedTests.TBNetconfProxy(self._nc_session, UtCompositeYang, self.log)\n self._netconf_test_objects = []\n self._pbreq_test_objects = []\n\n for cls in NETCONF_TESTS:\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\n yield from obj.dts_self_register()\n self._netconf_test_objects.append(obj)\n\n for cls in PBREQ_TESTS:\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\n yield from obj.dts_self_register()\n self._pbreq_test_objects.append(obj)\n\n @asyncio.coroutine\n def run_all_tests(xact_info, action, ks_path, msg):\n ro1 = yield from self.run_tests(self._netconf_test_objects, msg.continue_on_failure)\n if ro1.failed_count is 0 or msg.continue_on_failure is True:\n ro2 = yield from self.run_tests(self._pbreq_test_objects, msg.continue_on_failure)\n\n ro = RwAgentTestbedYang.AgentTestsOp()\n ro.total_tests = ro1.total_tests + ro2.total_tests\n ro.passed_count = ro1.passed_count + ro2.passed_count\n ro.failed_count = ro1.failed_count + ro2.failed_count\n #ro.failed_tests = ro1.failed_tests + ro2.failed_tests\n\n xpath = \"O,/agt-tb:agent-tests\"\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\n\n @asyncio.coroutine\n def run_all_netconf_tests(xact_info, action, ks_path, msg):\n ro = yield from self.run_tests(self._netconf_test_objects)\n xpath = \"O,/agt-tb:agent-tests\"\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\n\n @asyncio.coroutine\n def run_all_pbreqs_tests(xact_info, action, ks_path, msg):\n ro = yield from self.run_tests(self._pbreq_test_objects)\n xpath = \"O,/agt-tb:agent-tests\"\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\n \n # Register for all test-cases\n yield from self._dts.register(\n xpath=\"I,/agt-tb:agent-tests/agt-tb:all\",\n flags=rwdts.Flag.PUBLISHER,\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_tests))\n\n # Register for per category all test-cases\n yield from self._dts.register(\n xpath=\"I,/agt-tb:agent-tests/agt-tb:netconf-tests/agt-tb:all\",\n flags=rwdts.Flag.PUBLISHER,\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_netconf_tests))\n\n yield from self._dts.register(\n xpath=\"I,/agt-tb:agent-tests/agt-tb:pb-request-tests/agt-tb:all\",\n flags=rwdts.Flag.PUBLISHER,\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_pbreqs_tests))","def test_network(self, weights, env, episodes, seed, network=None, timeout=None):\n return self.run(\n backend_test_network, weights, #model creation params\n self.network_generator, env, episodes, seed, #test network params\n timeout=timeout\n )","def run(self) -> None:\n self.test_sanity()\n if self.has_errors():\n return\n\n tests: List[Callable[[], None]] = [\n self.test_headlines_predefined,\n self.test_headlines_required,\n self.test_headlines_dependencies,\n self.test_headlines_order,\n self.test_headlines_named_entities,\n self.test_named_entities,\n self.test_reading_attributes,\n self.test_forbidden_words,\n self.test_unwanted_words,\n self.test_police_abbreviations,\n self.test_spelling,\n self.test_grammar_rules_regex,\n ]\n\n for test in tests:\n if self.stop_on_error and self.has_errors():\n break\n test()","def test_01(self):\n if _debug: TestIAmRouterToNetwork._debug(\"test_01\")\n\n # create a network\n tnet = TNetwork()\n\n # test device sends request\n tnet.iut.start_state.doc(\"1-1-0\") \\\n .call(tnet.iut.nse.i_am_router_to_network).doc(\"1-1-1\") \\\n .success()\n\n # network 1 sees router to networks 2 and 3\n tnet.sniffer1.start_state.doc(\"1-2-0\") \\\n .receive(IAmRouterToNetwork,\n iartnNetworkList=[2, 3],\n ).doc(\"1-2-1\") \\\n .success()\n\n # network 2 sees router to networks 1 and 3\n tnet.sniffer2.start_state.doc(\"1-3-0\") \\\n .receive(IAmRouterToNetwork,\n iartnNetworkList=[1, 3],\n ).doc(\"1-3-1\") \\\n .success()\n\n # network 3 sees router to networks 1 and 2\n tnet.sniffer3.start_state.doc(\"1-4-0\") \\\n .receive(IAmRouterToNetwork,\n iartnNetworkList=[1, 2],\n ).doc(\"1-4-1\") \\\n .success()\n\n # run the group\n tnet.run()","def _run_ci_test():\n _run_install(False)\n _run_coverage_html(False)\n _run_typecheck_xml(False)\n _run_lint(True)","def runTest(self):\n\t\tself.setUp()\n\t\tself.test_postopProgramming1()","def runTest(self):\n self.setUp()\n self.test_BiplaneRegistration1()","def test_get_network(self):\n pass","def main():\n # add all new test suites per test module here\n suite_date = test_date.suite()\n suite_ng = test_ng.suite()\n suite_page = test_page.suite()\n suite_container = test_container.suite()\n\n # add the suite to be tested here\n alltests = unittest.TestSuite((suite_date,\n suite_ng,\n suite_page,\n suite_container))\n\n # run the suite\n runner = unittest.TextTestRunner()\n runner.run(alltests)","def _run_local_tests(self, *args, **kwargs):\n pass","def test(self):\n for arch, python in self.python:\n self.run(f\"{python} -m pytest\")","def run_tests(tests):\n return [test(t) for t in tests]","def run_all_tests():\n successes = 0\n testsrun = 0\n testsdir = tests_dirpath()\n for test in os.listdir(testsdir):\n path = os.path.join(testsdir, test)\n if os.path.isdir(path):\n testsrun += 1\n if run_test(path):\n successes += 1\n print(\"--- %d/%d TESTS PASSED ---\" % (successes, testsrun))\n return successes == testsrun","def test_on_all(self) -> None:\n x_test, y_test = self.mnist.test.images, self.mnist.test.labels\n N = self.mnist.test.num_examples\n\n # I have replaced all -1 with self.mb_size to be sure about exact shapes of all layers.\n assert N % self.mb_size == 0,\\\n \"Sorry, mb_size must divide the number of images in test set\"\n\n results = np.array([0., 0.])\n for batch_no in range(N // self.mb_size):\n beg = batch_no * self.mb_size\n end = min(N, (batch_no + 1) * self.mb_size)\n len_batch = end - beg\n batch_results = np.array(self.test_on_batch(x_test[beg:end], y_test[beg:end]))\n results += batch_results * len_batch\n results /= N\n self.logger.info(\"(Test(final): Loss: {0[0]}, accuracy: {0[1]}\".format(results))","def net():\n suite = ServiceTestSuite()\n suite.addTest(unittest.makeSuite(Test, 'test_net'))\n return suite","def test():\n import unittest\n testmodules = [\n 'bettermathlib_tests',\n 'randomwebapp_tests',\n ]\n suite = unittest.TestSuite()\n for t in testmodules:\n suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))\n unittest.TextTestRunner(verbosity=2).run(suite)","def run_training_save_tests():\n test_training_save()\n test_distributed_training_save()\n test_multimodel_training_save()\n test_distributed_multimodel_training_save()","def exe_tests(self):\n self.rank = mpicom.rank()\n self.size = mpicom.size()\n if mpicom.parallel():\n self.test(\"libname\",os.path.split(mpicom.__file__)[1],\"mpicom.so\")\n else:\n self.test(\"libname\",os.path.split(mpicom.__file__)[1],\"mpistub.pyc\")\n self.test_broadcast()\n self.test_reduce()\n self.test_p2p()\n self.test_gather()\n self.test_scatter()\n #self.test_alltoall()","def test(all=False):\n\n # Do the import internally, so that this function doesn't increase total\n # import time\n from iptest import run_iptestall\n run_iptestall(inc_slow=all)","def run(self, args):\n start_time = time.time()\n self._printer.write_update('Collecting tests ...')\n running_all_tests = False\n\n try:\n paths, all_test_names, running_all_tests = self._collect_tests(\n args)\n except IOError:\n # This is raised if --test-list doesn't exist\n return test_run_results.RunDetails(\n exit_code=exit_codes.NO_TESTS_EXIT_STATUS)\n\n test_names = self._finder.split_into_chunks(all_test_names)\n if self._options.order == 'natural':\n test_names.sort(key=self._port.test_key)\n elif self._options.order == 'random':\n test_names.sort()\n random.Random(self._options.seed).shuffle(test_names)\n elif self._options.order == 'none':\n # Restore the test order to user specified order.\n # base.tests() may change the order as it returns tests in the\n # real, external/wpt, virtual order.\n if paths:\n test_names = self._restore_order(paths, test_names)\n\n if not self._options.no_expectations:\n self._printer.write_update('Parsing expectations ...')\n self._expectations = test_expectations.TestExpectations(self._port)\n\n tests_to_run, tests_to_skip = self._prepare_lists(paths, test_names)\n\n self._printer.print_found(\n len(all_test_names), len(test_names), len(tests_to_run),\n self._options.repeat_each, self._options.iterations)\n\n # Check to make sure we're not skipping every test.\n if not tests_to_run:\n msg = 'No tests to run.'\n if self._options.zero_tests_executed_ok:\n _log.info(msg)\n # Keep executing to produce valid (but empty) results.\n else:\n _log.critical(msg)\n code = exit_codes.NO_TESTS_EXIT_STATUS\n return test_run_results.RunDetails(exit_code=code)\n\n exit_code = self._set_up_run(tests_to_run)\n if exit_code:\n return test_run_results.RunDetails(exit_code=exit_code)\n\n if self._options.num_retries is None:\n # If --test-list is passed, or if no test narrowing is specified,\n # default to 3 retries. Otherwise [e.g. if tests are being passed by\n # name], default to 0 retries.\n if self._options.test_list or len(paths) < len(test_names):\n self._options.num_retries = 3\n else:\n self._options.num_retries = 0\n\n should_retry_failures = self._options.num_retries > 0\n\n try:\n self._register_termination_handler()\n self._start_servers(tests_to_run)\n if self._options.watch:\n run_results = self._run_test_loop(tests_to_run, tests_to_skip)\n else:\n run_results = self._run_test_once(tests_to_run, tests_to_skip,\n should_retry_failures)\n initial_results, all_retry_results = run_results\n finally:\n _log.info(\"Finally stop servers and clean up\")\n self._stop_servers()\n self._clean_up_run()\n\n if self._options.no_expectations:\n return test_run_results.RunDetails(0, [], [], initial_results,\n all_retry_results)\n\n # Some crash logs can take a long time to be written out so look\n # for new logs after the test run finishes.\n self._printer.write_update('Looking for new crash logs ...')\n self._look_for_new_crash_logs(initial_results, start_time)\n for retry_attempt_results in all_retry_results:\n self._look_for_new_crash_logs(retry_attempt_results, start_time)\n\n self._printer.write_update('Summarizing results ...')\n summarized_full_results = test_run_results.summarize_results(\n self._port, self._options, self._expectations, initial_results,\n all_retry_results)\n summarized_failing_results = test_run_results.summarize_results(\n self._port,\n self._options,\n self._expectations,\n initial_results,\n all_retry_results,\n only_include_failing=True)\n run_histories = test_run_results.test_run_histories(\n self._options, self._expectations, initial_results,\n all_retry_results)\n\n exit_code = summarized_failing_results['num_regressions']\n if exit_code > exit_codes.MAX_FAILURES_EXIT_STATUS:\n _log.warning('num regressions (%d) exceeds max exit status (%d)',\n exit_code, exit_codes.MAX_FAILURES_EXIT_STATUS)\n exit_code = exit_codes.MAX_FAILURES_EXIT_STATUS\n\n if not self._options.dry_run:\n self._write_json_files(summarized_full_results,\n summarized_failing_results, initial_results,\n running_all_tests, run_histories)\n\n self._copy_results_html_file(self._artifacts_directory,\n 'results.html')\n if (initial_results.interrupt_reason is\n test_run_results.InterruptReason.EXTERNAL_SIGNAL):\n exit_code = exit_codes.INTERRUPTED_EXIT_STATUS\n else:\n if initial_results.interrupted:\n exit_code = exit_codes.EARLY_EXIT_STATUS\n if (self._options.show_results\n and (exit_code or initial_results.total_failures)):\n self._port.show_results_html_file(\n self._filesystem.join(self._artifacts_directory,\n 'results.html'))\n self._printer.print_results(time.time() - start_time,\n initial_results)\n\n return test_run_results.RunDetails(exit_code, summarized_full_results,\n summarized_failing_results,\n initial_results, all_retry_results)","def make_all():\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n member[1](master=True)\n print('done!')","def make_all():\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n member[1](master=True)\n print('done!')","def runTest(self):\n unittest.main()\n ChoreTest.clean_up()","def main():\n dims = params['dims']\n\n for d in dims:\n print('**** Running test for d={0:d} ****'.format(d))\n run_test(d)","def _run_tests(self):\n for pyunit_testcase in self.cfg.testcases:\n yield self._run_testsuite(pyunit_testcase)","def test():\n import unittest\n\n tests = unittest.TestLoader().discover(\"tests\")\n unittest.TextTestRunner(verbosity=2).run(tests)","def main():\n return run_network_interface_check()","def unittest():\n from a6test import test_all\n test_all()","def test_register_network(self):\n pass","def test():\n import unittest\n tests = unittest.TestLoader().discover(tests)\n unittest.TextTestRunner(verbosity=2).run(tests)","def RunAll():\n testfunctions = []\n for name, obj in inspect.getmembers(sys.modules[__name__]):\n if inspect.isfunction(obj) and name != 'RunAll':\n testfunctions.append(obj)\n\n # run all the functions\n for f in testfunctions:\n print('Running %s' % str(f))\n f()","def run_feature_extraction_tests():\n test_feature_extraction()\n test_distributed_feature_extraction()\n test_multimodel_feature_extraction()\n test_distributed_multimodel_feature_extraction()","def run_tests(remit, sourcelist):\n for source in sourcelist:\n # - move into source's directory\n os.chdir(source)\n # - build worklist of commands\n commands = list()\n commands += test_matrix(remit, source)\n commands += extra_tests(remit, source)\n commands = remove_blacklist(remit, source, commands)\n # - run the commands\n for i, command in enumerate(commands):\n print('[test %s: %s of %d] %s'\n % (source,\n str(i+1).rjust(len(str(len(commands)))),\n len(commands),\n ' '.join(command)))\n subprocess.call(command)\n # - move out of source's directory\n os.chdir('..')","def test():\n import unittest\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test_network(self):\n train_accuracy = 100 - percentError(map(self.neural_result,\n self.train_inputs),\n self.train_outputs)\n print 'Train accuracy:', train_accuracy\n\n test_accuracy = 100 - percentError(map(self.neural_result,\n self.test_inputs),\n self.test_outputs)\n print 'Test accuracy:', test_accuracy\n\n print '#' * int(train_accuracy), 'TR'\n print '#' * int(test_accuracy), 'TE'","def execute(self):\n for test in self.tests:\n test.execute()\n self.logger.dump()\n print(\"Finished!\")","def run_tests(self):\n # Trigger a config change which triggers a deferred hook.\n self.run_charm_change_hook_test('configure_ovs')\n\n # Trigger a package change which requires a restart\n self.run_package_change_test(\n 'openvswitch-switch',\n 'openvswitch-switch')","def run_tests(self):\n # Trigger a config change which triggers a deferred hook.\n self.run_charm_change_hook_test('configure_ovs')\n\n # Trigger a package change which requires a restart\n self.run_package_change_test(\n 'openvswitch-switch',\n 'openvswitch-switch')","def test_network(bpn, test_data):\n DisplayNetwork.display_green(\"[INFO] Started to test the network\")\n output = bpn.Run(np.array(test_data))\n return output","def run_tests(self):\n # Charm does not defer hooks so that test is not included.\n # Trigger a package change which requires a restart\n self.run_package_change_test(\n 'ovn-central',\n 'ovn-central')","def runWithDirector(global_options, create_input_store=True):\n from ooni.director import Director\n start_tor = False\n director = Director()\n if global_options['list']:\n net_tests = [net_test for net_test in director.getNetTests().items()]\n log.msg(\"\")\n log.msg(\"Installed nettests\")\n log.msg(\"==================\")\n for net_test_id, net_test in net_tests:\n optList = []\n for name, details in net_test['arguments'].items():\n optList.append({'long': name, 'doc': details['description']})\n\n desc = ('\\n' +\n net_test['name'] +\n '\\n' +\n '-'*len(net_test['name']) +\n '\\n' +\n '\\n'.join(textwrap.wrap(net_test['description'], 80)) +\n '\\n\\n' +\n '$ ooniprobe {}/{}'.format(net_test['category'],\n net_test['id']) +\n '\\n\\n' +\n ''.join(usage.docMakeChunks(optList))\n )\n map(log.msg, desc.split(\"\\n\"))\n log.msg(\"Note: Third party tests require an external \"\n \"application to run properly.\")\n\n raise SystemExit(0)\n\n if global_options.get('annotations') is not None:\n global_options['annotations'] = setupAnnotations(global_options)\n\n if global_options.get('preferred-backend') is not None:\n config.advanced.preferred_backend = global_options['preferred-backend']\n\n if global_options['no-collector']:\n log.msg(\"Not reporting using a collector\")\n global_options['collector'] = None\n start_tor = False\n elif config.advanced.get(\"preferred_backend\", \"onion\") == \"onion\":\n start_tor = True\n\n if (global_options['collector'] and\n config.advanced.get(\"preferred_backend\", \"onion\") == \"onion\"):\n start_tor |= True\n\n return runTestWithDirector(\n director=director,\n start_tor=start_tor,\n global_options=global_options,\n create_input_store=create_input_store\n )","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test():\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)","def test_03(self):\n if _debug: TestIAmRouterToNetwork._debug(\"test_03\")\n\n # create a network\n tnet = TNetwork()\n\n # test device sends request\n tnet.iut.start_state.doc(\"3-1-0\") \\\n .call(tnet.iut.nse.i_am_router_to_network,\n destination=Address(\"1:*\"),\n ).doc(\"3-1-1\") \\\n .success()\n\n # network 1 sees router to networks 2 and 3\n tnet.sniffer1.start_state.doc(\"3-2-0\") \\\n .receive(IAmRouterToNetwork,\n iartnNetworkList=[2, 3],\n ).doc(\"3-2-1\") \\\n .success()\n\n # network 2 sees nothing\n tnet.sniffer2.start_state.doc(\"3-3-0\") \\\n .timeout(10).doc(\"3-3-1\") \\\n .success()\n\n # network 3 sees nothing\n tnet.sniffer3.start_state.doc(\"3-4-0\") \\\n .timeout(10).doc(\"3-4-1\") \\\n .success()\n\n # run the group\n tnet.run()","def actionRunUnitTests():\n UnitTestRunner.init()\n \n for target in Settings.targets:\n for platform in Settings.targetPlatforms:\n for cpu in Settings.targetCPUs:\n for configuration in Settings.targetConfigurations:\n if not Summary.checkIfActionFailed(ACTION_BUILD, target, platform, cpu, configuration):\n Logger.printStartActionMessage('Running unit tests for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration, ColoredFormatter.YELLOW)\n result = UnitTestRunner.run(target, platform, cpu, configuration)\n Summary.addSummary(ACTION_RUN_UNITTESTS, target, platform, cpu, configuration, result, UnitTestRunner.executionTime)\n if result != NO_ERROR:\n Logger.printEndActionMessage('Failed to execute unit tests!')\n else:\n Logger.printEndActionMessage('Executed all unit tests')","def CASE3( self, main ):\n\n from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import SRRoutingTest\n\n SRRoutingTest.runTest( main,\n test_idx=3,\n onosNodes=3,\n dhcp=1,\n routers=1,\n ipv4=1,\n ipv6=1,\n countFlowsGroups=False,\n linkFailure=False,\n description=\"Ping between all ipv4 and ipv6 hosts in the topology\" )","def run_tests(self):\n manifest = manifestparser.TestManifest(\n manifests=[os.path.join(self.repository_path, self.manifest_path)],\n strict=False)\n\n tests = manifest.active_tests(**mozinfo.info)\n self._mozmill.run(tests, self.options.restart)\n\n # Whenever a test fails it has to be marked, so we quit with the correct exit code\n self.last_failed_tests = self.last_failed_tests or self._mozmill.results.fails\n\n self.testrun_index += 1","def test_and_multi_epoch(self):\n\n for epochs in range(10, 100, 10):\n perceptron, network, perceptron_estimated_values, \\\n network_estimated_values, perceptron_unit_error, network_unit_error \\\n = TestPerceptronNetwork.and_setup(epochs)\n\n self.assert_same_results(perceptron, network, perceptron_estimated_values,\n network_estimated_values, perceptron_unit_error,\n network_unit_error)","def test():\n\n tests = unittest.TestLoader().discover('api/tests/', pattern='*/test_*.py')\n unittest.TextTestRunner(verbosity=2).run(tests)","def runTest(self):\n self.setUp()\n self.test_FiberDistance1()","def runTests():\r\n\r\n print(\"running a few tests\")\r\n\r\n average = compute .gpsAverage (4, 5)\r\n print(\"average = \", average)\r\n \r\n print (\"hello!\")","def run_tests(output_dir, fstype):\n global options\n if options.debug:\n print \"Run NUMA test\"\n for num_disks in [2]:\n for num_dirs in range(1, 5):\n postmark = PostMarkTest(output_dir, fstype, num_disks, num_dirs)\n run_one_test(postmark)","def runTest(self):\n self.setUp()\n self.test_STLModelBuilder1()","def run_all_tests():\n model_configs = (model_handler.ModelConfig(\n saved_model_dir=platform_test.test_src_dir_path(\n \"python/compiler/tensorrt/model_tests/sample_model\"),\n default_batch_size=128),)\n if FLAGS.use_tf2:\n model_handler_cls = model_handler.ModelHandlerV2\n trt_model_handeler_cls = model_handler.TrtModelHandlerV2\n default_trt_convert_params = DEFAUL_TRT_CONVERT_PARAMS._replace(\n is_dynamic_op=True)\n else:\n model_handler_cls = model_handler.ModelHandlerV1\n trt_model_handeler_cls = model_handler.TrtModelHandlerV1\n default_trt_convert_params = DEFAUL_TRT_CONVERT_PARAMS._replace(\n is_dynamic_op=False)\n for model_config in model_configs:\n trt_convert_params = default_trt_convert_params._replace(\n max_batch_size=model_config.default_batch_size)\n base_model = model_handler_cls(model_config)\n random_inputs = base_model.generate_random_inputs()\n base_model_result = base_model.run(random_inputs)\n trt_fp32_model_result = trt_model_handeler_cls(\n model_config=model_config,\n trt_convert_params=trt_convert_params._replace(\n precision_mode=trt.TrtPrecisionMode.FP32)).run(random_inputs)\n trt_fp16_model_result = trt_model_handeler_cls(\n model_config=model_config,\n trt_convert_params=trt_convert_params._replace(\n precision_mode=trt.TrtPrecisionMode.FP16)).run(random_inputs)\n\n logging.info(\"Base model latency: %f ms\",\n _get_mean_latency(base_model_result))\n logging.info(\"TensorRT FP32 model latency: %f ms\",\n _get_mean_latency(trt_fp32_model_result))\n logging.info(\"TensorRT FP16 model latency: %f ms\",\n _get_mean_latency(trt_fp16_model_result))","def main_test():\n full = unittest.TestSuite()\n full.addTest(unittest.makeSuite(TestToolOptions))\n full.addTest(unittest.makeSuite(TestBadConfiguration))\n full.addTest(unittest.makeSuite(TestBasicEndpoints))\n full.addTest(unittest.makeSuite(TestMultipleEPG))\n full.addTest(unittest.makeSuite(TestBasicExistingEndpoints))\n full.addTest(unittest.makeSuite(TestBasicExistingEndpointsAddPolicyLater))\n full.addTest(unittest.makeSuite(TestExportPolicyRemoval))\n full.addTest(unittest.makeSuite(TestBasicEndpointsWithContract))\n full.addTest(unittest.makeSuite(TestBasicEndpointMove))\n full.addTest(unittest.makeSuite(TestPolicyChangeProvidedContract))\n full.addTest(unittest.makeSuite(TestChangeL3Out))\n full.addTest(unittest.makeSuite(TestDuplicates))\n full.addTest(unittest.makeSuite(TestDuplicatesTwoL3Outs))\n full.addTest(unittest.makeSuite(TestDeletions))\n\n unittest.main()","def run_tests():\n fail = []\n okay = []\n for i in os.listdir(\".\"):\n if i.find(\"_test_\") > -1 and i.endswith(\".py\"):\n if 0 != subprocess.call(\"python \" + i, shell=True):\n fail.append(i)\n else:\n okay.append(i)\n if fail:\n print(\"[ERROR] The following %u tests failed: %r\" % (len(fail), fail))\n return False\n print(\"[DONE] All %u tests completely successfully!\" % (len(okay)))\n return True","def testAutomodeNetwork(self):\n ### create test resources\n instance_name = \"end-to-end-test-instance-1\"\n instance_selfLink = \\\n self.test_resource_creator.create_instance_using_template(\n instance_name,\n self.test_resource_creator.legacy_instance_template_selfLink)[\n 'targetLink']\n original_config = self.google_api_interface.get_instance_configs(\n instance_name)\n auto_subnetwork_name = 'end-to-end-test-auto-subnetwork'\n try:\n network_selfLink = self.google_api_interface.get_network(auto_subnetwork_name)['selfLink']\n except:\n network_selfLink = self.google_api_interface.create_auto_subnetwork(auto_subnetwork_name)['targetLink']\n\n ### start migration\n selfLink_executor = SelfLinkExecutor(self.compute, instance_selfLink,\n auto_subnetwork_name,\n None,\n True)\n\n migration_handler = selfLink_executor.build_migration_handler()\n migration_handler.network_migration()\n\n ### check result\n new_config = self.google_api_interface.get_instance_configs(\n instance_name)\n self.assertTrue(\n resource_config_is_unchanged_except_for_network(new_config,\n original_config))\n self.assertTrue(\n compare_instance_external_ip(new_config, original_config))\n # network changed\n self.assertTrue(check_instance_network(new_config,\n network_selfLink,\n ))\n print('Pass the current test')","def setUp(self):\n sumo_bin = sumolib.checkBinary('sumo')\n traci.start([sumo_bin, \"-n\", self.network_path, \"-r\", self.routes_path])\n traci.simulationStep()"],"string":"[\n \"def test_all():\\n test_get_to()\\n test_error_type()\\n test_exchange()\\n print(\\\"All tests passed.\\\")\",\n \"def run_all_tests():\\n remove_dbs()\\n run_training_tests()\\n run_custom_training_tests()\\n run_training_save_tests()\\n run_validation_tests()\\n run_feature_extraction_tests()\",\n \"def runTests(self):\\n \\n pass\",\n \"def runAll():\\n\\n loader = unittest.TestLoader()\\n test_dir = pkg_resources.resource_filename('frvcpy.test','.')\\n suite = loader.discover(test_dir)\\n\\n runner = unittest.TextTestRunner(verbosity=2)\\n runner.run(suite)\",\n \"def main():\\n run_test_all()\",\n \"def doAllTests(self):\\n # Initial offset\\n self.getAlertsFile()\\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\\n\\n # Do all tests\\n # As the socket is not persistent, client side attacks have to be done before all tests\\n for module in self.modules:\\n # Test is performed only if selected in config.cfg\\n if self.config.get('TESTS', module[1]) == '1':\\n print \\\"\\\\n%s\\\\n------------\\\" % module[0].upper()\\n if module[1]=='clientSideAttacks':\\n self.doClientSideAttacksTest( clientSideAttacks.ClientSideAttacks(self._target).getPayloads() )\\n# elif module[1]=='multipleFailedLogins':\\n# self.doMultipleFailedLoginsTest( multipleFailedLogins.MultipleFailedLogins(self._target).getPayloads() )\\n else:\\n self.doTest( module[1], eval( ('%s.%s'+'(self._target,self._cnf).getPayloads()') % (module[1], module[1][:1].upper()+module[1][1:]) ) )\\n\\n # Done!\\n print \\\"\\\\n\\\\n-----------------------\\\"\\n print \\\"DONE. Check the report.\\\"\\n print \\\"-----------------------\\\\n\\\"\",\n \"def tests():\\n api.local('nosetests')\",\n \"def runalltests():\\n doctest.testmod()\",\n \"def run_tests():\\n \\n test_constructor_positive()\\n test_constructor_negative()\\n test_game_move_positive()\\n test_game_move_negative()\\n test_game_move_edge()\\n print(\\\"Congratulations ! You passed all the game test cases.\\\")\",\n \"def run_custom_training_tests():\\n test_custom_training()\\n test_custom_distributed_training()\\n test_custom_multimodel_training()\\n test_custom_distributed_multimodel_training()\",\n \"def test_run():\\n # Only few steps for test\\n timesteps = 128\\n\\n # Compute all sub testing conf\\n envs = ['CartPole-v0']\\n ml_platforms = ['torch', 'tf']\\n agents = ['dqn', 'a2c']\\n\\n test_combinations = list(it.product(\\n envs,\\n ml_platforms,\\n agents\\n )\\n )\\n\\n # Finally test them all\\n for conf in test_combinations:\\n env_str, ml_platform_str, agent_str = conf\\n run(\\n agent_str,\\n ml_platform_str,\\n env_str,\\n 'dense',\\n timesteps,\\n './target/')\",\n \"def run_all_tests(self):\\n for index in range(len(self.__test_set_list)):\\n self.run_test(index)\",\n \"def test_get_networks(self):\\n pass\",\n \"def test_core(c):\\n def test_python(c, filename):\\n \\\"\\\"\\\"Run a single python test file in tests/python.\\\"\\\"\\\"\\n test_dir = 'tests/python'\\n filepath = '{}/{}'.format(test_dir, filename)\\n\\n print('Restarting network before executing test {}'.format(filepath))\\n rm_network(c)\\n start_core(c)\\n start_horizon(c)\\n network(c)\\n\\n with c.cd(test_dir):\\n print('Executing test {}'.format(filepath))\\n c.run('pipenv run python {filename} \\\"{passphrase}\\\" {whitelist_seed}'.format(\\n filename=filename,\\n passphrase=PASSPHRASE,\\n whitelist_seed=WHITELIST_SEED))\\n\\n test_python(c, 'test_base_reserve.py')\\n test_python(c, 'test_tx_order_by_fee.py')\\n test_python(c, 'test_tx_order_by_whitelist.py')\\n test_python(c, 'test_tx_priority_for_whitelist_holder.py')\\n test_python(c, 'test_whitelist_affected_on_next_ledger.py')\\n\\n # XXX obsolete\\n # see source file for more information\\n # test_python(c, 'test_multiple_cores.py')\",\n \"def main():\\r\\n test = TesterNeighbour()\\r\\n test.setUp()\\r\\n test.test_result_n()\\r\\n print(\\\"result_of_algorithm_test - passed\\\")\",\n \"def run_tests(self):\\n raise NotImplementedError\",\n \"def tests():\",\n \"def main():\\n test_network_connection()\\n parser()\",\n \"def RunTest(self):\\n self.TestLs()\\n self.TestTerminate()\\n self.TestMultipleProcesses()\",\n \"def main():\\n test_runner = TestRunner(\\n FLAGS.workspace, FLAGS.bench_home, imagenet_dir=FLAGS.train_data_dir)\\n test_runner.run_tests(FLAGS.test_list.split(','))\",\n \"def run_all(self):\\n failures, errors = [], []\\n\\n # Run each test case registered with us and agglomerate the results.\\n for case_ in self.cases:\\n case_.run()\\n update_results(failures, errors, case_)\\n\\n # Display our results.\\n print_errors(errors)\\n print_failures(failures)\\n print_overview(errors, failures)\\n\\n # Exit with 0 if all tests passed, >0 otherwise.\\n sys.exit(len(failures) + len(errors))\",\n \"def run_all_unit_tests(cls):\\n suites_list = []\\n for test_class in cls.TESTS:\\n suite = unittest.TestLoader().loadTestsFromTestCase(test_class)\\n suites_list.append(suite)\\n result = unittest.TextTestRunner().run(unittest.TestSuite(suites_list))\\n if not result.wasSuccessful() or result.errors:\\n raise Exception(result)\",\n \"def RunTestAll(ss):\\n ss.StopNow = False\\n ss.TestAll()\\n ss.Stopped()\",\n \"def run_test_cases(self):\\n count = 1\\n for test_case in self.test_cases:\\n print(\\\"Running test case #%d\\\" % count)\\n if test_case.name == 'RouteDistance':\\n distance = self.get_distance_for_route(test_case.args)\\n print('%s distance: %s' % (test_case.args, distance))\\n elif test_case.name == 'RouteShortest':\\n args = test_case.args.split('|')\\n shortest_distance = self.find_shortest_path_between_cities(args[0], args[1])\\n print(\\\"Shortest distance between %s and %s: %d\\\" % (args[0], args[1], shortest_distance))\\n elif test_case.name == 'RouteLessThanHops':\\n args = test_case.args.split('|')\\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]))\\n print('Paths between %s and %s with hops less than or equal to %d: %d (%s)' % (\\n args[0], args[1], int(args[2]), len(paths), paths\\n ))\\n elif test_case.name == 'RouteEqualHops':\\n args = test_case.args.split('|')\\n paths = self.trips_hop_constraint_bfs(args[0], args[1], int(args[2]), equal=True)\\n print('Paths between %s and %s with hops equal to %d: %d (%s)' % (\\n args[0], args[1], int(args[2]), len(paths), paths\\n ))\\n elif test_case.name == 'RouteLessThanDistance':\\n args = test_case.args.split('|')\\n paths = self.trips_distance_constraint_bfs(args[0], args[1], int(args[2]))\\n print('Paths between %s and %s with distance less than %d: %d (%s)' % (\\n args[0], args[1], int(args[2]), len(paths), paths\\n ))\\n else:\\n raise Exception('Unknown test case: %s' % test_case.name)\\n count += 1\\n print()\",\n \"def run_all_tests(self) -> None:\\n self.run_trt_precision_tests()\\n logging.info(\\\"Check analysis result at: %s\\\", self._output_dir)\",\n \"def test_add_network(self):\\n pass\",\n \"def runtest(self):\",\n \"def run(self):\\n if self.all:\\n cmd = self.apply_options(self.test_all_cmd)\\n self.call_and_exit(cmd)\\n else:\\n cmds = (self.apply_options(self.unit_test_cmd, (\\\"coverage\\\",)),)\\n if self.coverage:\\n cmds += (self.apply_options(self.coverage_cmd),)\\n self.call_in_sequence(cmds)\",\n \"def main(tests, root_uri, verbose):\\n if verbose:\\n rv_config.set_verbosity(verbosity=Verbosity.DEBUG)\\n\\n if len(tests) == 0:\\n # no tests specified, so run all\\n tests = list(ALL_TESTS.keys())\\n else:\\n # run all tests that start with the given string e.g \\\"chip\\\" will match\\n # both \\\"chip_classification.basic\\\" and \\\"chip_classification.nochip\\\"\\n _tests = []\\n for t in tests:\\n t = t.strip().lower()\\n matching_tests = [k for k in ALL_TESTS.keys() if k.startswith(t)]\\n _tests.extend(matching_tests)\\n if len(matching_tests) == 0:\\n console_error(\\n f'{t} does not match any valid tests. Valid tests are: ')\\n console_error(pformat(list(ALL_TESTS.keys())))\\n continue\\n tests = _tests\\n\\n console_info('The following tests will be run:')\\n console_info(pformat(tests, compact=False))\\n\\n with get_tmp_dir() as tmp_dir:\\n if root_uri:\\n tmp_dir = root_uri\\n\\n num_failed = 0\\n errors = {}\\n for test_id in tests:\\n test_cfg = ALL_TESTS[test_id]\\n errors[test_id] = run_test(test_id, test_cfg, tmp_dir)\\n if len(errors[test_id]) > 0:\\n num_failed += 1\\n\\n for error in errors[test_id]:\\n console_error(str(error))\\n\\n for test_id in tests:\\n if test_id not in errors:\\n continue\\n if len(errors[test_id]) == 0:\\n console_success(f'{test_id}: test passed!', bold=True)\\n else:\\n console_error(f'{test_id}: test failed!', bold=True)\\n\\n if num_failed > 0:\\n console_error(\\n f'Tests passed: {len(tests) - num_failed} of {len(tests)}')\\n console_error('Error counts:')\\n console_error(pformat({k: len(es) for k, es in errors.items()}))\\n exit(1)\",\n \"def run():\\n\\tsubsuite_list = []\\n\\tfor _, modname, _ in pkgutil.iter_modules(test.__path__):\\n\\t\\tif modname.startswith(\\\"test_\\\"):\\n\\t\\t\\tmodule = importlib.import_module('test.' + modname)\\n\\t\\t\\tsubsuite = unittest.TestLoader().loadTestsFromModule(module)\\n\\t\\t\\tsubsuite_list.append(subsuite)\\n\\tsuite = unittest.TestSuite(subsuite_list)\\n\\n\\tprint(\\\"Testing:\\\\n\\\")\\n\\tunittest.TextTestRunner(verbosity=2).run(suite)\",\n \"def test_generate_all_testing(self):\\n pass\",\n \"def train(self, iterations=1):\\n for _ in range(iterations):\\n self.trainer.train()\\n self.test_network()\",\n \"def runTest(self):\\n self.setUp()\\n self.test_NeuroPath1()\",\n \"def run_tests(self):\\n setup_layers = {}\\n layers_to_run = list(self.ordered_layers())\\n should_resume = False\\n\\n while layers_to_run:\\n layer_name, layer, tests = layers_to_run[0]\\n for feature in self.features:\\n feature.layer_setup(layer)\\n try:\\n self.ran += run_layer(self.options, layer_name, layer, tests,\\n setup_layers, self.failures, self.errors,\\n self.skipped, self.import_errors)\\n except zope.testrunner.interfaces.EndRun:\\n self.failed = True\\n break\\n except CanNotTearDown:\\n if not self.options.resume_layer:\\n should_resume = True\\n break\\n\\n layers_to_run.pop(0)\\n if self.options.processes > 1:\\n should_resume = True\\n break\\n\\n if self.options.stop_on_error and (self.failures or self.errors):\\n break\\n\\n if should_resume:\\n if layers_to_run:\\n self.ran += resume_tests(\\n self.script_parts, self.options, self.features,\\n layers_to_run, self.failures, self.errors,\\n self.skipped, self.cwd)\\n\\n if setup_layers:\\n if self.options.resume_layer is None:\\n self.options.output.info(\\\"Tearing down left over layers:\\\")\\n tear_down_unneeded(\\n self.options, (), setup_layers, self.errors, optional=True)\\n\\n self.failed = bool(self.import_errors or self.failures or self.errors)\",\n \"def main():\\n run_test_summary1a()\\n run_test_summary1c()\\n run_test_summary1c()\",\n \"def runAllTests():\\n\\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\\n\\tnTests = ttr.testsRun + len(ttr.skipped)\\n\\tprint(\\\"Report:\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.failures)) + \\\"/\\\" + str(nTests) + \\\" failed\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.errors)) + \\\"/\\\" + str(nTests) + \\\" errors\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.skipped)) + \\\"/\\\" + str(nTests) + \\\" skipped\\\")\",\n \"def __main() :\\n launchTests()\",\n \"def test_all():\\n test_prepare_text()\\n test_end_chat()\\n test_choose_author()\\n test_choose_book()\",\n \"def runtests():\\n #- Load all TestCase classes from desistar/test/test_*.py\\n tests = desistar_test_suite()\\n #- Run them\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def run_tests():\\n good_car = UnreliableCar(\\\"Good Car\\\", 100, 90)\\n bad_car = UnreliableCar(\\\"Bad Car\\\", 100, 10)\\n\\n for i in range(1, 15):\\n print(\\\"Attempting to drive {}km:\\\".format(i))\\n print(\\\"{:12} drove {:2}km\\\".format(good_car.name, good_car.drive(i)))\\n print(\\\"{:12} drove {:2}km\\\".format(bad_car.name, bad_car.drive(i)))\\n\\n \\\"\\\"\\\"final states of the cars\\\"\\\"\\\"\\n print(good_car)\\n print(bad_car)\",\n \"def run_tests(self):\\n\\n self.manifest_path = os.path.join('tests',\\n 'remote',\\n 'manifest.ini')\\n TestRun.run_tests(self)\",\n \"def test_routers(self):\\n if self.output_file == '':\\n self.run_suite()\\n else:\\n with open(self.output_file, \\\"w\\\") as fp:\\n self.run_suite(fp)\",\n \"def init(self):\\n \\n self._nc_session = TestBedTests.TBNetconfSession(self.log, self.loop)\\n self._nc_proxy = TestBedTests.TBNetconfProxy(self._nc_session, UtCompositeYang, self.log)\\n self._netconf_test_objects = []\\n self._pbreq_test_objects = []\\n\\n for cls in NETCONF_TESTS:\\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\\n yield from obj.dts_self_register()\\n self._netconf_test_objects.append(obj)\\n\\n for cls in PBREQ_TESTS:\\n obj = cls(self._dts, self.log, self._nc_proxy, self._loop)\\n yield from obj.dts_self_register()\\n self._pbreq_test_objects.append(obj)\\n\\n @asyncio.coroutine\\n def run_all_tests(xact_info, action, ks_path, msg):\\n ro1 = yield from self.run_tests(self._netconf_test_objects, msg.continue_on_failure)\\n if ro1.failed_count is 0 or msg.continue_on_failure is True:\\n ro2 = yield from self.run_tests(self._pbreq_test_objects, msg.continue_on_failure)\\n\\n ro = RwAgentTestbedYang.AgentTestsOp()\\n ro.total_tests = ro1.total_tests + ro2.total_tests\\n ro.passed_count = ro1.passed_count + ro2.passed_count\\n ro.failed_count = ro1.failed_count + ro2.failed_count\\n #ro.failed_tests = ro1.failed_tests + ro2.failed_tests\\n\\n xpath = \\\"O,/agt-tb:agent-tests\\\"\\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\\n\\n @asyncio.coroutine\\n def run_all_netconf_tests(xact_info, action, ks_path, msg):\\n ro = yield from self.run_tests(self._netconf_test_objects)\\n xpath = \\\"O,/agt-tb:agent-tests\\\"\\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\\n\\n @asyncio.coroutine\\n def run_all_pbreqs_tests(xact_info, action, ks_path, msg):\\n ro = yield from self.run_tests(self._pbreq_test_objects)\\n xpath = \\\"O,/agt-tb:agent-tests\\\"\\n xact_info.respond_xpath(rwdts.XactRspCode.ACK, xpath, ro)\\n \\n # Register for all test-cases\\n yield from self._dts.register(\\n xpath=\\\"I,/agt-tb:agent-tests/agt-tb:all\\\",\\n flags=rwdts.Flag.PUBLISHER,\\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_tests))\\n\\n # Register for per category all test-cases\\n yield from self._dts.register(\\n xpath=\\\"I,/agt-tb:agent-tests/agt-tb:netconf-tests/agt-tb:all\\\",\\n flags=rwdts.Flag.PUBLISHER,\\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_netconf_tests))\\n\\n yield from self._dts.register(\\n xpath=\\\"I,/agt-tb:agent-tests/agt-tb:pb-request-tests/agt-tb:all\\\",\\n flags=rwdts.Flag.PUBLISHER,\\n handler=rift.tasklets.DTS.RegistrationHandler(on_prepare=run_all_pbreqs_tests))\",\n \"def test_network(self, weights, env, episodes, seed, network=None, timeout=None):\\n return self.run(\\n backend_test_network, weights, #model creation params\\n self.network_generator, env, episodes, seed, #test network params\\n timeout=timeout\\n )\",\n \"def run(self) -> None:\\n self.test_sanity()\\n if self.has_errors():\\n return\\n\\n tests: List[Callable[[], None]] = [\\n self.test_headlines_predefined,\\n self.test_headlines_required,\\n self.test_headlines_dependencies,\\n self.test_headlines_order,\\n self.test_headlines_named_entities,\\n self.test_named_entities,\\n self.test_reading_attributes,\\n self.test_forbidden_words,\\n self.test_unwanted_words,\\n self.test_police_abbreviations,\\n self.test_spelling,\\n self.test_grammar_rules_regex,\\n ]\\n\\n for test in tests:\\n if self.stop_on_error and self.has_errors():\\n break\\n test()\",\n \"def test_01(self):\\n if _debug: TestIAmRouterToNetwork._debug(\\\"test_01\\\")\\n\\n # create a network\\n tnet = TNetwork()\\n\\n # test device sends request\\n tnet.iut.start_state.doc(\\\"1-1-0\\\") \\\\\\n .call(tnet.iut.nse.i_am_router_to_network).doc(\\\"1-1-1\\\") \\\\\\n .success()\\n\\n # network 1 sees router to networks 2 and 3\\n tnet.sniffer1.start_state.doc(\\\"1-2-0\\\") \\\\\\n .receive(IAmRouterToNetwork,\\n iartnNetworkList=[2, 3],\\n ).doc(\\\"1-2-1\\\") \\\\\\n .success()\\n\\n # network 2 sees router to networks 1 and 3\\n tnet.sniffer2.start_state.doc(\\\"1-3-0\\\") \\\\\\n .receive(IAmRouterToNetwork,\\n iartnNetworkList=[1, 3],\\n ).doc(\\\"1-3-1\\\") \\\\\\n .success()\\n\\n # network 3 sees router to networks 1 and 2\\n tnet.sniffer3.start_state.doc(\\\"1-4-0\\\") \\\\\\n .receive(IAmRouterToNetwork,\\n iartnNetworkList=[1, 2],\\n ).doc(\\\"1-4-1\\\") \\\\\\n .success()\\n\\n # run the group\\n tnet.run()\",\n \"def _run_ci_test():\\n _run_install(False)\\n _run_coverage_html(False)\\n _run_typecheck_xml(False)\\n _run_lint(True)\",\n \"def runTest(self):\\n\\t\\tself.setUp()\\n\\t\\tself.test_postopProgramming1()\",\n \"def runTest(self):\\n self.setUp()\\n self.test_BiplaneRegistration1()\",\n \"def test_get_network(self):\\n pass\",\n \"def main():\\n # add all new test suites per test module here\\n suite_date = test_date.suite()\\n suite_ng = test_ng.suite()\\n suite_page = test_page.suite()\\n suite_container = test_container.suite()\\n\\n # add the suite to be tested here\\n alltests = unittest.TestSuite((suite_date,\\n suite_ng,\\n suite_page,\\n suite_container))\\n\\n # run the suite\\n runner = unittest.TextTestRunner()\\n runner.run(alltests)\",\n \"def _run_local_tests(self, *args, **kwargs):\\n pass\",\n \"def test(self):\\n for arch, python in self.python:\\n self.run(f\\\"{python} -m pytest\\\")\",\n \"def run_tests(tests):\\n return [test(t) for t in tests]\",\n \"def run_all_tests():\\n successes = 0\\n testsrun = 0\\n testsdir = tests_dirpath()\\n for test in os.listdir(testsdir):\\n path = os.path.join(testsdir, test)\\n if os.path.isdir(path):\\n testsrun += 1\\n if run_test(path):\\n successes += 1\\n print(\\\"--- %d/%d TESTS PASSED ---\\\" % (successes, testsrun))\\n return successes == testsrun\",\n \"def test_on_all(self) -> None:\\n x_test, y_test = self.mnist.test.images, self.mnist.test.labels\\n N = self.mnist.test.num_examples\\n\\n # I have replaced all -1 with self.mb_size to be sure about exact shapes of all layers.\\n assert N % self.mb_size == 0,\\\\\\n \\\"Sorry, mb_size must divide the number of images in test set\\\"\\n\\n results = np.array([0., 0.])\\n for batch_no in range(N // self.mb_size):\\n beg = batch_no * self.mb_size\\n end = min(N, (batch_no + 1) * self.mb_size)\\n len_batch = end - beg\\n batch_results = np.array(self.test_on_batch(x_test[beg:end], y_test[beg:end]))\\n results += batch_results * len_batch\\n results /= N\\n self.logger.info(\\\"(Test(final): Loss: {0[0]}, accuracy: {0[1]}\\\".format(results))\",\n \"def net():\\n suite = ServiceTestSuite()\\n suite.addTest(unittest.makeSuite(Test, 'test_net'))\\n return suite\",\n \"def test():\\n import unittest\\n testmodules = [\\n 'bettermathlib_tests',\\n 'randomwebapp_tests',\\n ]\\n suite = unittest.TestSuite()\\n for t in testmodules:\\n suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))\\n unittest.TextTestRunner(verbosity=2).run(suite)\",\n \"def run_training_save_tests():\\n test_training_save()\\n test_distributed_training_save()\\n test_multimodel_training_save()\\n test_distributed_multimodel_training_save()\",\n \"def exe_tests(self):\\n self.rank = mpicom.rank()\\n self.size = mpicom.size()\\n if mpicom.parallel():\\n self.test(\\\"libname\\\",os.path.split(mpicom.__file__)[1],\\\"mpicom.so\\\")\\n else:\\n self.test(\\\"libname\\\",os.path.split(mpicom.__file__)[1],\\\"mpistub.pyc\\\")\\n self.test_broadcast()\\n self.test_reduce()\\n self.test_p2p()\\n self.test_gather()\\n self.test_scatter()\\n #self.test_alltoall()\",\n \"def test(all=False):\\n\\n # Do the import internally, so that this function doesn't increase total\\n # import time\\n from iptest import run_iptestall\\n run_iptestall(inc_slow=all)\",\n \"def run(self, args):\\n start_time = time.time()\\n self._printer.write_update('Collecting tests ...')\\n running_all_tests = False\\n\\n try:\\n paths, all_test_names, running_all_tests = self._collect_tests(\\n args)\\n except IOError:\\n # This is raised if --test-list doesn't exist\\n return test_run_results.RunDetails(\\n exit_code=exit_codes.NO_TESTS_EXIT_STATUS)\\n\\n test_names = self._finder.split_into_chunks(all_test_names)\\n if self._options.order == 'natural':\\n test_names.sort(key=self._port.test_key)\\n elif self._options.order == 'random':\\n test_names.sort()\\n random.Random(self._options.seed).shuffle(test_names)\\n elif self._options.order == 'none':\\n # Restore the test order to user specified order.\\n # base.tests() may change the order as it returns tests in the\\n # real, external/wpt, virtual order.\\n if paths:\\n test_names = self._restore_order(paths, test_names)\\n\\n if not self._options.no_expectations:\\n self._printer.write_update('Parsing expectations ...')\\n self._expectations = test_expectations.TestExpectations(self._port)\\n\\n tests_to_run, tests_to_skip = self._prepare_lists(paths, test_names)\\n\\n self._printer.print_found(\\n len(all_test_names), len(test_names), len(tests_to_run),\\n self._options.repeat_each, self._options.iterations)\\n\\n # Check to make sure we're not skipping every test.\\n if not tests_to_run:\\n msg = 'No tests to run.'\\n if self._options.zero_tests_executed_ok:\\n _log.info(msg)\\n # Keep executing to produce valid (but empty) results.\\n else:\\n _log.critical(msg)\\n code = exit_codes.NO_TESTS_EXIT_STATUS\\n return test_run_results.RunDetails(exit_code=code)\\n\\n exit_code = self._set_up_run(tests_to_run)\\n if exit_code:\\n return test_run_results.RunDetails(exit_code=exit_code)\\n\\n if self._options.num_retries is None:\\n # If --test-list is passed, or if no test narrowing is specified,\\n # default to 3 retries. Otherwise [e.g. if tests are being passed by\\n # name], default to 0 retries.\\n if self._options.test_list or len(paths) < len(test_names):\\n self._options.num_retries = 3\\n else:\\n self._options.num_retries = 0\\n\\n should_retry_failures = self._options.num_retries > 0\\n\\n try:\\n self._register_termination_handler()\\n self._start_servers(tests_to_run)\\n if self._options.watch:\\n run_results = self._run_test_loop(tests_to_run, tests_to_skip)\\n else:\\n run_results = self._run_test_once(tests_to_run, tests_to_skip,\\n should_retry_failures)\\n initial_results, all_retry_results = run_results\\n finally:\\n _log.info(\\\"Finally stop servers and clean up\\\")\\n self._stop_servers()\\n self._clean_up_run()\\n\\n if self._options.no_expectations:\\n return test_run_results.RunDetails(0, [], [], initial_results,\\n all_retry_results)\\n\\n # Some crash logs can take a long time to be written out so look\\n # for new logs after the test run finishes.\\n self._printer.write_update('Looking for new crash logs ...')\\n self._look_for_new_crash_logs(initial_results, start_time)\\n for retry_attempt_results in all_retry_results:\\n self._look_for_new_crash_logs(retry_attempt_results, start_time)\\n\\n self._printer.write_update('Summarizing results ...')\\n summarized_full_results = test_run_results.summarize_results(\\n self._port, self._options, self._expectations, initial_results,\\n all_retry_results)\\n summarized_failing_results = test_run_results.summarize_results(\\n self._port,\\n self._options,\\n self._expectations,\\n initial_results,\\n all_retry_results,\\n only_include_failing=True)\\n run_histories = test_run_results.test_run_histories(\\n self._options, self._expectations, initial_results,\\n all_retry_results)\\n\\n exit_code = summarized_failing_results['num_regressions']\\n if exit_code > exit_codes.MAX_FAILURES_EXIT_STATUS:\\n _log.warning('num regressions (%d) exceeds max exit status (%d)',\\n exit_code, exit_codes.MAX_FAILURES_EXIT_STATUS)\\n exit_code = exit_codes.MAX_FAILURES_EXIT_STATUS\\n\\n if not self._options.dry_run:\\n self._write_json_files(summarized_full_results,\\n summarized_failing_results, initial_results,\\n running_all_tests, run_histories)\\n\\n self._copy_results_html_file(self._artifacts_directory,\\n 'results.html')\\n if (initial_results.interrupt_reason is\\n test_run_results.InterruptReason.EXTERNAL_SIGNAL):\\n exit_code = exit_codes.INTERRUPTED_EXIT_STATUS\\n else:\\n if initial_results.interrupted:\\n exit_code = exit_codes.EARLY_EXIT_STATUS\\n if (self._options.show_results\\n and (exit_code or initial_results.total_failures)):\\n self._port.show_results_html_file(\\n self._filesystem.join(self._artifacts_directory,\\n 'results.html'))\\n self._printer.print_results(time.time() - start_time,\\n initial_results)\\n\\n return test_run_results.RunDetails(exit_code, summarized_full_results,\\n summarized_failing_results,\\n initial_results, all_retry_results)\",\n \"def make_all():\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n member[1](master=True)\\n print('done!')\",\n \"def make_all():\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n member[1](master=True)\\n print('done!')\",\n \"def runTest(self):\\n unittest.main()\\n ChoreTest.clean_up()\",\n \"def main():\\n dims = params['dims']\\n\\n for d in dims:\\n print('**** Running test for d={0:d} ****'.format(d))\\n run_test(d)\",\n \"def _run_tests(self):\\n for pyunit_testcase in self.cfg.testcases:\\n yield self._run_testsuite(pyunit_testcase)\",\n \"def test():\\n import unittest\\n\\n tests = unittest.TestLoader().discover(\\\"tests\\\")\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def main():\\n return run_network_interface_check()\",\n \"def unittest():\\n from a6test import test_all\\n test_all()\",\n \"def test_register_network(self):\\n pass\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover(tests)\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def RunAll():\\n testfunctions = []\\n for name, obj in inspect.getmembers(sys.modules[__name__]):\\n if inspect.isfunction(obj) and name != 'RunAll':\\n testfunctions.append(obj)\\n\\n # run all the functions\\n for f in testfunctions:\\n print('Running %s' % str(f))\\n f()\",\n \"def run_feature_extraction_tests():\\n test_feature_extraction()\\n test_distributed_feature_extraction()\\n test_multimodel_feature_extraction()\\n test_distributed_multimodel_feature_extraction()\",\n \"def run_tests(remit, sourcelist):\\n for source in sourcelist:\\n # - move into source's directory\\n os.chdir(source)\\n # - build worklist of commands\\n commands = list()\\n commands += test_matrix(remit, source)\\n commands += extra_tests(remit, source)\\n commands = remove_blacklist(remit, source, commands)\\n # - run the commands\\n for i, command in enumerate(commands):\\n print('[test %s: %s of %d] %s'\\n % (source,\\n str(i+1).rjust(len(str(len(commands)))),\\n len(commands),\\n ' '.join(command)))\\n subprocess.call(command)\\n # - move out of source's directory\\n os.chdir('..')\",\n \"def test():\\n import unittest\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test_network(self):\\n train_accuracy = 100 - percentError(map(self.neural_result,\\n self.train_inputs),\\n self.train_outputs)\\n print 'Train accuracy:', train_accuracy\\n\\n test_accuracy = 100 - percentError(map(self.neural_result,\\n self.test_inputs),\\n self.test_outputs)\\n print 'Test accuracy:', test_accuracy\\n\\n print '#' * int(train_accuracy), 'TR'\\n print '#' * int(test_accuracy), 'TE'\",\n \"def execute(self):\\n for test in self.tests:\\n test.execute()\\n self.logger.dump()\\n print(\\\"Finished!\\\")\",\n \"def run_tests(self):\\n # Trigger a config change which triggers a deferred hook.\\n self.run_charm_change_hook_test('configure_ovs')\\n\\n # Trigger a package change which requires a restart\\n self.run_package_change_test(\\n 'openvswitch-switch',\\n 'openvswitch-switch')\",\n \"def run_tests(self):\\n # Trigger a config change which triggers a deferred hook.\\n self.run_charm_change_hook_test('configure_ovs')\\n\\n # Trigger a package change which requires a restart\\n self.run_package_change_test(\\n 'openvswitch-switch',\\n 'openvswitch-switch')\",\n \"def test_network(bpn, test_data):\\n DisplayNetwork.display_green(\\\"[INFO] Started to test the network\\\")\\n output = bpn.Run(np.array(test_data))\\n return output\",\n \"def run_tests(self):\\n # Charm does not defer hooks so that test is not included.\\n # Trigger a package change which requires a restart\\n self.run_package_change_test(\\n 'ovn-central',\\n 'ovn-central')\",\n \"def runWithDirector(global_options, create_input_store=True):\\n from ooni.director import Director\\n start_tor = False\\n director = Director()\\n if global_options['list']:\\n net_tests = [net_test for net_test in director.getNetTests().items()]\\n log.msg(\\\"\\\")\\n log.msg(\\\"Installed nettests\\\")\\n log.msg(\\\"==================\\\")\\n for net_test_id, net_test in net_tests:\\n optList = []\\n for name, details in net_test['arguments'].items():\\n optList.append({'long': name, 'doc': details['description']})\\n\\n desc = ('\\\\n' +\\n net_test['name'] +\\n '\\\\n' +\\n '-'*len(net_test['name']) +\\n '\\\\n' +\\n '\\\\n'.join(textwrap.wrap(net_test['description'], 80)) +\\n '\\\\n\\\\n' +\\n '$ ooniprobe {}/{}'.format(net_test['category'],\\n net_test['id']) +\\n '\\\\n\\\\n' +\\n ''.join(usage.docMakeChunks(optList))\\n )\\n map(log.msg, desc.split(\\\"\\\\n\\\"))\\n log.msg(\\\"Note: Third party tests require an external \\\"\\n \\\"application to run properly.\\\")\\n\\n raise SystemExit(0)\\n\\n if global_options.get('annotations') is not None:\\n global_options['annotations'] = setupAnnotations(global_options)\\n\\n if global_options.get('preferred-backend') is not None:\\n config.advanced.preferred_backend = global_options['preferred-backend']\\n\\n if global_options['no-collector']:\\n log.msg(\\\"Not reporting using a collector\\\")\\n global_options['collector'] = None\\n start_tor = False\\n elif config.advanced.get(\\\"preferred_backend\\\", \\\"onion\\\") == \\\"onion\\\":\\n start_tor = True\\n\\n if (global_options['collector'] and\\n config.advanced.get(\\\"preferred_backend\\\", \\\"onion\\\") == \\\"onion\\\"):\\n start_tor |= True\\n\\n return runTestWithDirector(\\n director=director,\\n start_tor=start_tor,\\n global_options=global_options,\\n create_input_store=create_input_store\\n )\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test():\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def test_03(self):\\n if _debug: TestIAmRouterToNetwork._debug(\\\"test_03\\\")\\n\\n # create a network\\n tnet = TNetwork()\\n\\n # test device sends request\\n tnet.iut.start_state.doc(\\\"3-1-0\\\") \\\\\\n .call(tnet.iut.nse.i_am_router_to_network,\\n destination=Address(\\\"1:*\\\"),\\n ).doc(\\\"3-1-1\\\") \\\\\\n .success()\\n\\n # network 1 sees router to networks 2 and 3\\n tnet.sniffer1.start_state.doc(\\\"3-2-0\\\") \\\\\\n .receive(IAmRouterToNetwork,\\n iartnNetworkList=[2, 3],\\n ).doc(\\\"3-2-1\\\") \\\\\\n .success()\\n\\n # network 2 sees nothing\\n tnet.sniffer2.start_state.doc(\\\"3-3-0\\\") \\\\\\n .timeout(10).doc(\\\"3-3-1\\\") \\\\\\n .success()\\n\\n # network 3 sees nothing\\n tnet.sniffer3.start_state.doc(\\\"3-4-0\\\") \\\\\\n .timeout(10).doc(\\\"3-4-1\\\") \\\\\\n .success()\\n\\n # run the group\\n tnet.run()\",\n \"def actionRunUnitTests():\\n UnitTestRunner.init()\\n \\n for target in Settings.targets:\\n for platform in Settings.targetPlatforms:\\n for cpu in Settings.targetCPUs:\\n for configuration in Settings.targetConfigurations:\\n if not Summary.checkIfActionFailed(ACTION_BUILD, target, platform, cpu, configuration):\\n Logger.printStartActionMessage('Running unit tests for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration, ColoredFormatter.YELLOW)\\n result = UnitTestRunner.run(target, platform, cpu, configuration)\\n Summary.addSummary(ACTION_RUN_UNITTESTS, target, platform, cpu, configuration, result, UnitTestRunner.executionTime)\\n if result != NO_ERROR:\\n Logger.printEndActionMessage('Failed to execute unit tests!')\\n else:\\n Logger.printEndActionMessage('Executed all unit tests')\",\n \"def CASE3( self, main ):\\n\\n from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import SRRoutingTest\\n\\n SRRoutingTest.runTest( main,\\n test_idx=3,\\n onosNodes=3,\\n dhcp=1,\\n routers=1,\\n ipv4=1,\\n ipv6=1,\\n countFlowsGroups=False,\\n linkFailure=False,\\n description=\\\"Ping between all ipv4 and ipv6 hosts in the topology\\\" )\",\n \"def run_tests(self):\\n manifest = manifestparser.TestManifest(\\n manifests=[os.path.join(self.repository_path, self.manifest_path)],\\n strict=False)\\n\\n tests = manifest.active_tests(**mozinfo.info)\\n self._mozmill.run(tests, self.options.restart)\\n\\n # Whenever a test fails it has to be marked, so we quit with the correct exit code\\n self.last_failed_tests = self.last_failed_tests or self._mozmill.results.fails\\n\\n self.testrun_index += 1\",\n \"def test_and_multi_epoch(self):\\n\\n for epochs in range(10, 100, 10):\\n perceptron, network, perceptron_estimated_values, \\\\\\n network_estimated_values, perceptron_unit_error, network_unit_error \\\\\\n = TestPerceptronNetwork.and_setup(epochs)\\n\\n self.assert_same_results(perceptron, network, perceptron_estimated_values,\\n network_estimated_values, perceptron_unit_error,\\n network_unit_error)\",\n \"def test():\\n\\n tests = unittest.TestLoader().discover('api/tests/', pattern='*/test_*.py')\\n unittest.TextTestRunner(verbosity=2).run(tests)\",\n \"def runTest(self):\\n self.setUp()\\n self.test_FiberDistance1()\",\n \"def runTests():\\r\\n\\r\\n print(\\\"running a few tests\\\")\\r\\n\\r\\n average = compute .gpsAverage (4, 5)\\r\\n print(\\\"average = \\\", average)\\r\\n \\r\\n print (\\\"hello!\\\")\",\n \"def run_tests(output_dir, fstype):\\n global options\\n if options.debug:\\n print \\\"Run NUMA test\\\"\\n for num_disks in [2]:\\n for num_dirs in range(1, 5):\\n postmark = PostMarkTest(output_dir, fstype, num_disks, num_dirs)\\n run_one_test(postmark)\",\n \"def runTest(self):\\n self.setUp()\\n self.test_STLModelBuilder1()\",\n \"def run_all_tests():\\n model_configs = (model_handler.ModelConfig(\\n saved_model_dir=platform_test.test_src_dir_path(\\n \\\"python/compiler/tensorrt/model_tests/sample_model\\\"),\\n default_batch_size=128),)\\n if FLAGS.use_tf2:\\n model_handler_cls = model_handler.ModelHandlerV2\\n trt_model_handeler_cls = model_handler.TrtModelHandlerV2\\n default_trt_convert_params = DEFAUL_TRT_CONVERT_PARAMS._replace(\\n is_dynamic_op=True)\\n else:\\n model_handler_cls = model_handler.ModelHandlerV1\\n trt_model_handeler_cls = model_handler.TrtModelHandlerV1\\n default_trt_convert_params = DEFAUL_TRT_CONVERT_PARAMS._replace(\\n is_dynamic_op=False)\\n for model_config in model_configs:\\n trt_convert_params = default_trt_convert_params._replace(\\n max_batch_size=model_config.default_batch_size)\\n base_model = model_handler_cls(model_config)\\n random_inputs = base_model.generate_random_inputs()\\n base_model_result = base_model.run(random_inputs)\\n trt_fp32_model_result = trt_model_handeler_cls(\\n model_config=model_config,\\n trt_convert_params=trt_convert_params._replace(\\n precision_mode=trt.TrtPrecisionMode.FP32)).run(random_inputs)\\n trt_fp16_model_result = trt_model_handeler_cls(\\n model_config=model_config,\\n trt_convert_params=trt_convert_params._replace(\\n precision_mode=trt.TrtPrecisionMode.FP16)).run(random_inputs)\\n\\n logging.info(\\\"Base model latency: %f ms\\\",\\n _get_mean_latency(base_model_result))\\n logging.info(\\\"TensorRT FP32 model latency: %f ms\\\",\\n _get_mean_latency(trt_fp32_model_result))\\n logging.info(\\\"TensorRT FP16 model latency: %f ms\\\",\\n _get_mean_latency(trt_fp16_model_result))\",\n \"def main_test():\\n full = unittest.TestSuite()\\n full.addTest(unittest.makeSuite(TestToolOptions))\\n full.addTest(unittest.makeSuite(TestBadConfiguration))\\n full.addTest(unittest.makeSuite(TestBasicEndpoints))\\n full.addTest(unittest.makeSuite(TestMultipleEPG))\\n full.addTest(unittest.makeSuite(TestBasicExistingEndpoints))\\n full.addTest(unittest.makeSuite(TestBasicExistingEndpointsAddPolicyLater))\\n full.addTest(unittest.makeSuite(TestExportPolicyRemoval))\\n full.addTest(unittest.makeSuite(TestBasicEndpointsWithContract))\\n full.addTest(unittest.makeSuite(TestBasicEndpointMove))\\n full.addTest(unittest.makeSuite(TestPolicyChangeProvidedContract))\\n full.addTest(unittest.makeSuite(TestChangeL3Out))\\n full.addTest(unittest.makeSuite(TestDuplicates))\\n full.addTest(unittest.makeSuite(TestDuplicatesTwoL3Outs))\\n full.addTest(unittest.makeSuite(TestDeletions))\\n\\n unittest.main()\",\n \"def run_tests():\\n fail = []\\n okay = []\\n for i in os.listdir(\\\".\\\"):\\n if i.find(\\\"_test_\\\") > -1 and i.endswith(\\\".py\\\"):\\n if 0 != subprocess.call(\\\"python \\\" + i, shell=True):\\n fail.append(i)\\n else:\\n okay.append(i)\\n if fail:\\n print(\\\"[ERROR] The following %u tests failed: %r\\\" % (len(fail), fail))\\n return False\\n print(\\\"[DONE] All %u tests completely successfully!\\\" % (len(okay)))\\n return True\",\n \"def testAutomodeNetwork(self):\\n ### create test resources\\n instance_name = \\\"end-to-end-test-instance-1\\\"\\n instance_selfLink = \\\\\\n self.test_resource_creator.create_instance_using_template(\\n instance_name,\\n self.test_resource_creator.legacy_instance_template_selfLink)[\\n 'targetLink']\\n original_config = self.google_api_interface.get_instance_configs(\\n instance_name)\\n auto_subnetwork_name = 'end-to-end-test-auto-subnetwork'\\n try:\\n network_selfLink = self.google_api_interface.get_network(auto_subnetwork_name)['selfLink']\\n except:\\n network_selfLink = self.google_api_interface.create_auto_subnetwork(auto_subnetwork_name)['targetLink']\\n\\n ### start migration\\n selfLink_executor = SelfLinkExecutor(self.compute, instance_selfLink,\\n auto_subnetwork_name,\\n None,\\n True)\\n\\n migration_handler = selfLink_executor.build_migration_handler()\\n migration_handler.network_migration()\\n\\n ### check result\\n new_config = self.google_api_interface.get_instance_configs(\\n instance_name)\\n self.assertTrue(\\n resource_config_is_unchanged_except_for_network(new_config,\\n original_config))\\n self.assertTrue(\\n compare_instance_external_ip(new_config, original_config))\\n # network changed\\n self.assertTrue(check_instance_network(new_config,\\n network_selfLink,\\n ))\\n print('Pass the current test')\",\n \"def setUp(self):\\n sumo_bin = sumolib.checkBinary('sumo')\\n traci.start([sumo_bin, \\\"-n\\\", self.network_path, \\\"-r\\\", self.routes_path])\\n traci.simulationStep()\"\n]"},"negative_scores":{"kind":"list like","value":["0.7459378","0.74455136","0.7278033","0.71453613","0.713573","0.7003208","0.69377714","0.6935737","0.6916369","0.68943274","0.6879508","0.6857769","0.67931044","0.6778059","0.6765904","0.675124","0.67291695","0.66894144","0.66677123","0.6644143","0.66383016","0.66262877","0.6606613","0.65838885","0.65819764","0.6575092","0.6560523","0.65121496","0.6498272","0.6486818","0.6473093","0.64716804","0.6462493","0.6453718","0.6447231","0.64346874","0.6416155","0.6393734","0.63839215","0.63750714","0.63733876","0.63679796","0.6366267","0.6364766","0.6361186","0.6359695","0.63449484","0.63288456","0.6327869","0.631808","0.6306854","0.62915","0.629062","0.62853813","0.62805665","0.6279111","0.627527","0.6272608","0.6264477","0.6261897","0.6246347","0.6242292","0.6236423","0.6236423","0.62357223","0.62352246","0.62344855","0.6231711","0.62198985","0.62170976","0.62089044","0.61940396","0.618697","0.6174979","0.6164178","0.6163468","0.61597663","0.6157005","0.6155535","0.6155535","0.615398","0.61510664","0.61473453","0.6140028","0.6140028","0.6140028","0.6135964","0.6131416","0.61288404","0.6128426","0.6109904","0.61080134","0.6102849","0.609976","0.60980934","0.6088969","0.60838574","0.6079074","0.60788894","0.607493","0.60718"],"string":"[\n \"0.7459378\",\n \"0.74455136\",\n \"0.7278033\",\n \"0.71453613\",\n \"0.713573\",\n \"0.7003208\",\n \"0.69377714\",\n \"0.6935737\",\n \"0.6916369\",\n \"0.68943274\",\n \"0.6879508\",\n \"0.6857769\",\n \"0.67931044\",\n \"0.6778059\",\n \"0.6765904\",\n \"0.675124\",\n \"0.67291695\",\n \"0.66894144\",\n \"0.66677123\",\n \"0.6644143\",\n \"0.66383016\",\n \"0.66262877\",\n \"0.6606613\",\n \"0.65838885\",\n \"0.65819764\",\n \"0.6575092\",\n \"0.6560523\",\n \"0.65121496\",\n \"0.6498272\",\n \"0.6486818\",\n \"0.6473093\",\n \"0.64716804\",\n \"0.6462493\",\n \"0.6453718\",\n \"0.6447231\",\n \"0.64346874\",\n \"0.6416155\",\n \"0.6393734\",\n \"0.63839215\",\n \"0.63750714\",\n \"0.63733876\",\n \"0.63679796\",\n \"0.6366267\",\n \"0.6364766\",\n \"0.6361186\",\n \"0.6359695\",\n \"0.63449484\",\n \"0.63288456\",\n \"0.6327869\",\n \"0.631808\",\n \"0.6306854\",\n \"0.62915\",\n \"0.629062\",\n \"0.62853813\",\n \"0.62805665\",\n \"0.6279111\",\n \"0.627527\",\n \"0.6272608\",\n \"0.6264477\",\n \"0.6261897\",\n \"0.6246347\",\n \"0.6242292\",\n \"0.6236423\",\n \"0.6236423\",\n \"0.62357223\",\n \"0.62352246\",\n \"0.62344855\",\n \"0.6231711\",\n \"0.62198985\",\n \"0.62170976\",\n \"0.62089044\",\n \"0.61940396\",\n \"0.618697\",\n \"0.6174979\",\n \"0.6164178\",\n \"0.6163468\",\n \"0.61597663\",\n \"0.6157005\",\n \"0.6155535\",\n \"0.6155535\",\n \"0.615398\",\n \"0.61510664\",\n \"0.61473453\",\n \"0.6140028\",\n \"0.6140028\",\n \"0.6140028\",\n \"0.6135964\",\n \"0.6131416\",\n \"0.61288404\",\n \"0.6128426\",\n \"0.6109904\",\n \"0.61080134\",\n \"0.6102849\",\n \"0.609976\",\n \"0.60980934\",\n \"0.6088969\",\n \"0.60838574\",\n \"0.6079074\",\n \"0.60788894\",\n \"0.607493\",\n \"0.60718\"\n]"},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":1693,"cells":{"query":{"kind":"string","value":"enforceZeroSlope ensures that the last slope of all elbow fits is always 0"},"document":{"kind":"string","value":"def find_elbows_per_boots(dfr, nElbows, enforceZeroSlope=False):\n rows = []\n for dotmode, dfp in dfr.groupby('dotmode'):\n if dotmode == '3d':\n # always take out 3d's first two dis\n # since pcor's correlation with duration is too weak to fit pmf\n dfp = remove_dis(dfp, [1, 2], dotmode)\n for bi, dfpts in dfp.groupby('bi'):\n row = find_elbows_one_boot(dfpts, nElbows, enforceZeroSlope)\n row.update({'dotmode': dotmode, 'bi': bi})\n rows.append(row)\n return pd.DataFrame(rows)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def fit_slope_with_zero_intercept_residue(X,Y):\n X = np.array(X)\n Y = np.array(Y)\n slope = np.sum(Y*X)/np.sum(np.power(X,2))\n return slope*X - Y","def zeroCrossing(self,evap_threshold):\r\n\t\tself.splitBaseline =(np.mean(self.splitData[0:10]))\t\r\n\t\tsplit_max_index = np.argmax(self.splitData)\r\n\t\tsplit_min_index = np.argmin(self.splitData)\r\n\r\n\t\tif split_max_index >= split_min_index:\r\n\t\t\treturn self.zeroCrossingPosSlope(evap_threshold)\r\n\t\t\r\n\t\tif split_max_index < split_min_index:\r\n\t\t\treturn self.zeroCrossingNegSlope(evap_threshold)","def leakyrelu(x, negative_slope: float = 0.01):\n return np.max(x, 0) + negative_slope * np.min(-x, 0)","def zeroCrossingNegSlope(self, evap_threshold):\r\n\t\tself.splitBaseline = np.mean(self.splitData[0:10])\r\n\t\ttry:\r\n\t\t\tsplit_min_index = np.argmin(self.splitData)\r\n\t\t\tsplit_max_index = np.argmax(self.splitData[0:split_min_index])\r\n\t\t\tsplit_max_value = self.splitData[split_max_index]\r\n\t\t\tsplit_min_value = self.splitData[split_min_index]\r\n\t\texcept:\r\n\t\t\tzero_crossing = -3\r\n\t\t\treturn zero_crossing\r\n\t\t#print 'split',\tsplit_min_index, (self.splitBaseline-split_min_value), split_max_index,(split_max_value-self.splitBaseline)\r\n\t\tif (self.splitBaseline-split_min_value) >= evap_threshold and (split_max_value-self.splitBaseline) >= evap_threshold: #avoid particles evaporating before the notch position can be properly determined (details in Taylor et al. 10.5194/amtd-7-5491-2014)\r\n\t\t\ttry:\r\n\t\t\t\tfor index in range(split_max_index, split_min_index+1): #go to max +1 because 'range' function is not inclusive\r\n\t\t\t\t\tif self.splitData[index] > self.splitBaseline:\r\n\t\t\t\t\t\tvalue_zero_cross_pos = float(self.splitData[index])\r\n\t\t\t\t\t\tindex_zero_cross_pos = index\r\n\t\t\t\t\tif self.splitData[index] <= self.splitBaseline:\r\n\t\t\t\t\t\tvalue_zero_cross_neg = float(self.splitData[index])\r\n\t\t\t\t\t\tindex_zero_cross_neg = index\r\n\t\t\t\t\t\tbreak\r\n\t\t\t\tzero_crossing = index+((value_zero_cross_pos-self.splitBaseline)*(index_zero_cross_pos-index_zero_cross_neg))/(value_zero_cross_pos-value_zero_cross_neg) \r\n\t\t\texcept:\r\n\t\t\t\tzero_crossing = -1\r\n\t\t\r\n\t\telse: \r\n\t\t\tzero_crossing = -2\r\n\r\n\t\tself.zeroCrossingPos = zero_crossing\r\n\t\treturn zero_crossing","def zeroCrossingPosSlope(self, evap_threshold):\r\n\t\tself.splitBaseline = np.mean(self.splitData[0:10])\r\n\t\tsplit_max_index = np.argmax(self.splitData)\r\n\t\tsplit_min_index = np.argmin(self.splitData[0:split_max_index])\r\n\t\tsplit_max_value = self.splitData[split_max_index]\r\n\t\tsplit_min_value = self.splitData[split_min_index]\r\n\r\n\t\tif (self.splitBaseline-split_min_value) >= evap_threshold and (split_max_value-self.splitBaseline) >=evap_threshold: #avoid particles evaporating before the notch position can be properly determined (details in Taylor et al. 10.5194/amtd-7-5491-2014)\r\n\t\t\ttry:\r\n\t\t\t\tfor index in range(split_min_index, split_max_index+1): #go to max +1 because 'range' function is not inclusive\r\n\t\t\t\t\tif self.splitData[index] < self.splitBaseline:\r\n\t\t\t\t\t\tvalue_zero_cross_neg = float(self.splitData[index])\r\n\t\t\t\t\t\tindex_zero_cross_neg = index\r\n\t\t\t\t\tif self.splitData[index] >= self.splitBaseline:\r\n\t\t\t\t\t\tvalue_zero_cross_pos = float(self.splitData[index])\r\n\t\t\t\t\t\tindex_zero_cross_pos = index\r\n\t\t\t\t\t\tbreak\r\n\t\t\t\tzero_crossing = index+((value_zero_cross_pos-self.splitBaseline)*(index_zero_cross_pos-index_zero_cross_neg))/(value_zero_cross_pos-value_zero_cross_neg) \r\n\t\t\texcept:\r\n\t\t\t\tzero_crossing = -1 \r\n\t\t\t\t\r\n\t\telse:\r\n\t\t\tzero_crossing = -2 \r\n\t\t\r\n\t\tself.zeroCrossingPos = zero_crossing\r\n\t\treturn zero_crossing","def testSlopeSetNegative(self):\n def setSlope():\n self.cc.slope = [-1.3782, 278.32, 0.738378233782]\n\n cdl_convert.config.HALT_ON_ERROR = True\n\n self.assertRaises(\n ValueError,\n setSlope\n )\n\n cdl_convert.config.HALT_ON_ERROR = False\n\n setSlope()\n\n self.assertEqual(\n (Decimal('0.0'), Decimal('278.32'), Decimal('0.738378233782')),\n self.cc.slope\n )","def testSlopeSetNegative(self):\n def setSlope():\n self.node.slope = [-1.3782, 278.32, 0.738378233782]\n\n cdl_convert.config.HALT_ON_ERROR = True\n\n self.assertRaises(\n ValueError,\n setSlope\n )\n\n cdl_convert.config.HALT_ON_ERROR = False\n\n setSlope()\n\n self.assertEqual(\n (Decimal('0.0'), Decimal('278.32'), Decimal('0.738378233782')),\n self.node.slope\n )","def test_positive_slope(self):\n slopes = []\n for i in range(100):\n neighborhood, pc = create_point_cloud_in_plane_and_neighborhood()\n slopes += list(EigenValueVectorizeFeatureExtractor().extract(pc, neighborhood, None, None, None)[6])\n np.testing.assert_array_less(np.zeros_like(slopes), slopes)","def find_zero_cross(x, y):\r\n\r\n try:\r\n zp = np.where(y[:-1] * y[1:] <= 0)[0][0] #make a list of A[x] * A[x -1] without usinf \"for\" loop in original python.\r\n m = np.polyfit(x[(zp - 1):(zp + 1)], y[(zp -1):(zp + 1)], 1)\r\n zc = -m[1]/m[0] #For y = ax + b and y = 0, then x = -b/a.\r\n\r\n except:\r\n print 'error at zero_cross'\r\n zc = 0\r\n\r\n return zc","def calculate_edges_zero(self, verbose = False):\n\n ## calculates the first and last wavelength that has non-zero\n # w = np.where(self.throughput > 0)[0]\n # if verbose: print(w)\n # self._upper_edge = self.wavelength[w[-1]]\n # self._lower_edge = self.wavelength[w[0]]\n\n w = np.where(self.throughput > 0)[0]\n if verbose: print(w)\n if w[0] - 1 < 0:\n w_low = 0\n else:\n w_low = w[0] - 1\n\n if w[-1] + 1 == len(self.throughput):\n w_high = w[-1]\n else:\n w_high = w[-1] + 1\n\n self._upper_edge = self.wavelength[w_high]\n self._lower_edge = self.wavelength[w_low]","def test_check_null_weight_with_zeros() -> None:\n sample_weight = np.ones_like(y_toy)\n sample_weight[:1] = 0.0\n sw_out, X_out, y_out = check_null_weight(sample_weight, X_toy, y_toy)\n np.testing.assert_almost_equal(sw_out, np.array([1, 1, 1, 1, 1]))\n np.testing.assert_almost_equal(X_out, np.array([[1], [2], [3], [4], [5]]))\n np.testing.assert_almost_equal(y_out, np.array([7, 9, 11, 13, 15]))","def slope(self):\n if self.b == 0:\n return None\n else:\n return (-1) * self.a/self.b","def testSetSlopeWithNegativeInt(self):\n def setSlope():\n self.node.slope = -20\n\n cdl_convert.config.HALT_ON_ERROR = True\n\n self.assertRaises(\n ValueError,\n setSlope\n )\n\n cdl_convert.config.HALT_ON_ERROR = False\n\n setSlope()\n\n self.assertEqual(\n (Decimal('0.0'), Decimal('0.0'), Decimal('0.0')),\n self.node.slope\n )","def slope(a, b):\r\n if a[0] == b[0]: #If the x values are both 0\r\n return 0 #Technically, undefined, but doesn't matter for finding collinearity\r\n return (a[1] - b[1]) / (a[0] - b[0])","def test__validate_with_synthetic_data(elbow_with_synthetic_data):\n x, y, break_pt = elbow_with_synthetic_data\n expected_elbow = np.argmin(np.abs(x - break_pt))\n assert expected_elbow == find_elbow_point(x, y)","def testSetSlopeWithNegativeFloat(self):\n def setSlope():\n self.node.slope = -20.1\n\n cdl_convert.config.HALT_ON_ERROR = True\n\n self.assertRaises(\n ValueError,\n setSlope\n )\n\n cdl_convert.config.HALT_ON_ERROR = False\n\n setSlope()\n\n self.assertEqual(\n (Decimal('0.0'), Decimal('0.0'), Decimal('0.0')),\n self.node.slope\n )","def test_non_linear_fit_zero_degree_polynomial_with_weights(fitter):\n\n model = models.Polynomial1D(0, c0=0)\n fitter = fitter()\n\n x = np.arange(10, dtype=float)\n y = np.ones((10,))\n weights = np.ones((10,))\n\n fit = fitter(model, x, y)\n assert_almost_equal(fit.c0, 1.0)\n\n fit = fitter(model, x, y, weights=weights)\n assert_almost_equal(fit.c0, 1.0)","def loss_piecewise(y, a):\n if not y: # Runs if y == 0\n return -1 * np.log10(1 - a)\n else: # Runs if y != 0\n return -1 * np.log10(a)","def asymtotic_approx(self, zero_crossings):\n x = np.sqrt(2 * np.log(zero_crossings))\n return x + 0.5772 / x","def test_null_bootstrapping(self):\n\n apply = lambda p, x, i: x[:, :1]\n output = apply(self._params, self._batch.x, self._index)\n # y is zero, hence the loss is just the mean square of the output.\n expected_loss = np.mean(np.square(output))\n\n loss_fn = single_index.L2Loss()\n loss, unused_metrics = loss_fn(\n apply=apply, params=self._params, batch=self._batch, index=self._index)\n self.assertEqual(\n loss, expected_loss,\n (f'expected loss with null bootstrapping is {expected_loss}, '\n f'but it is {loss}'))","def findzero(x,y):\n\t\targs = np.where(y > 0)[0]\n\t\tif len(args) == 0:\n\t\t\tprint \"Unable to find zero! Using maximum T.\"\n\t\t\ti = len(y) - 1\n\t\telse:\n\t\t\ti = min(args)\n\n\t\t#Do a fit using the surrounding points, and perform interpolation based on that\n\t\tp = np.polyfit(x[i-1:i+1],y[i-1:i+1],1)\n\t\tyfit = p[0]*x[i-1:i+1] + p[1]\n\t\tf = interp.interp1d(yfit, x[i-1:i+1])\n\t\treturn float(f(0))","def test_non_zero_loss(self):\n # Reset models.\n self.model.load_state_dict(self.initial_model_dict)\n self.actor_model.load_state_dict(self.initial_actor_model_dict)\n\n polybeast.learn(*self.learn_args)\n\n self.assertNotEqual(self.stats[\"total_loss\"], 0.0)\n self.assertNotEqual(self.stats[\"pg_loss\"], 0.0)\n self.assertNotEqual(self.stats[\"baseline_loss\"], 0.0)\n self.assertNotEqual(self.stats[\"entropy_loss\"], 0.0)","def test_intra_power_law_fit_no_model(self):\n\n\t\tdetails= self.watcher.analyze(model=self.model, layers=self.fc_layers, intra=True, randomize=False, vectors=False)\n\t\tactual_alpha = details.alpha[0]\n\n\t\texpected_alpha = 2.654 # not very accurate because of the sparisify transform\n\t\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=1)","def test_elbo_loss(self):\n\n batch_size = 4\n batch = base.Batch(\n x=np.expand_dims(np.arange(batch_size), 1),\n y=np.arange(batch_size),\n )\n params = dict()\n apply = lambda p, x, i: x[:, 0]\n index = np.array([])\n output = apply(params, batch.x, index)\n\n log_likelihood_fn = lambda out, batch: out\n model_prior_kl_fn = lambda out, params, index: np.zeros_like(out)\n\n elbo_loss = ElboLoss(\n log_likelihood_fn=log_likelihood_fn,\n model_prior_kl_fn=model_prior_kl_fn)\n\n loss, unused_loss_metrics = elbo_loss(\n apply=apply, params=params, batch=batch, index=index)\n self.assertTrue((loss == -output).all(),\n f'expected elbo loss to be {-output} but it is {loss}')","def are_residuals_near_zero(pts):\n y = regress(pts)[1]\n return all(map(near_zero, y))","def grad_zero(self):\r\n pass","def grad_zero(self):\r\n pass","def test_Sobol_G_raises_error_if_values_lt_zero():\n evaluate(np.array([0, -1, -.02, 1, 1, -0.1, -0, -12]))","def test_invalid_target(self):\n y_valid = np.random.randint(2, size=100)\n y_invalid = np.random.uniform(size=100)\n\n oz = ClassBalance()\n\n with pytest.raises(YellowbrickValueError):\n oz.fit(y_invalid)\n\n with pytest.raises(YellowbrickValueError):\n oz.fit(y_valid, y_invalid)","def testSlopeBadLength(self):\n def setSlope():\n self.node.slope = ['banana']\n\n self.assertRaises(\n ValueError,\n setSlope\n )","def test_check_null_weight_with_nonzeros() -> None:\n sample_weight = np.ones_like(y_toy)\n sw_out, X_out, y_out = check_null_weight(sample_weight, X_toy, y_toy)\n np.testing.assert_almost_equal(sw_out, sample_weight)\n np.testing.assert_almost_equal(X_out, X_toy)\n np.testing.assert_almost_equal(y_out, y_toy)","def model_zero(df, offset, harmonize_year=\"2015\"):\n # current decision is to return a simple offset, this will be a straight\n # line for all time periods. previous behavior was to set df[numcols] = 0,\n # i.e., report 0 if model reports 0.\n return constant_offset(df, offset)","def zero_one_loss(self, normalize=True):\n zero_one_loss = len((self.y_true - self.y_pred).nonzero()[0])\n if normalize:\n zero_one_loss /= len(self.y_pred)\n return zero_one_loss","def set_zero(self, loc=None):\n self.Y[loc] -= self.Y[loc]","def zero_negative_weights(self):\n for k in range(len(self)):\n self[k] *= 0 if self[k] < 0 else 1\n self.finalized = True\n return self","def testSetSlopeWithNegativeString(self):\n def setSlope():\n self.node.slope = '-20'\n\n cdl_convert.config.HALT_ON_ERROR = True\n\n self.assertRaises(\n ValueError,\n setSlope\n )\n\n cdl_convert.config.HALT_ON_ERROR = False\n\n setSlope()\n\n self.assertEqual(\n (Decimal('0.0'), Decimal('0.0'), Decimal('0.0')),\n self.node.slope\n )","def elbow_with_synthetic_data():\n delta = 0.1\n slope_2 = 2\n slope_3 = 3\n break_pt = 5\n intercept_2 = 0.0\n line_2 = np.arange(0, break_pt, delta) * slope_2 + intercept_2\n line_3 = (\n np.arange(break_pt, break_pt * 2, delta) * slope_3\n + (slope_2 - slope_3) * break_pt\n )\n x = np.arange(0, break_pt * 2, delta)\n y = np.concatenate((line_2, line_3))\n break_pt = break_pt\n\n return x, y, break_pt","def __init__(self, negative_slope=0.01, inplace=False):\n super(LeakyReLU, self).__init__()\n self.negative_slope = negative_slope\n self.inplace = inplace","def grad_zero(self):\r\n for layer in self.layers:\r\n layer.grad_zero()","def test_greaterThanZero(self):\n\t\tX = []\n\t\tY1 = []\n\t\tY2 = []\n\t\tcandidate = [0,2,3,4]\n\t\tfor i in range(DATA_POINTS_NUM):\n\t\t\tX.append((i - DATA_POINTS_NUM/2)*0.1)\n\t\t\tY1.append(polynomi_3N(REFERENCE, X[-1]))\n\t\t\tY2.append(polynomi_3N(candidate, X[-1]))\n\t\tret = calculate_fitness(Y1, Y2)\n\t\tself.assertFalse( 0 > ret, \n\t\t \"Something wrong with fitness calculation\")\n\t\tprint ret","def test__validate_nan_output(straight_line):\n x, y0, y1, y2 = straight_line\n # Horizontal line\n elbow = find_elbow_point(x, y0)\n assert np.isnan(elbow)\n\n # Vertical line\n elbow = find_elbow_point(x, y2)\n assert np.isnan(elbow)\n\n # A line, but no elbow.\n elbow = find_elbow_point(x, y1)\n assert np.isnan(elbow)","def test_extreme_values(self):\n with pytest.warns(RuntimeWarning) as warninfo:\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\n with pytest.warns(RuntimeWarning) as warninfo:\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0","def min_zero_crossings(self):\n return self._MIN_ZERO_CROSSINGS","def testSlopeBadLength(self):\n def setSlope():\n self.cc.slope = ['banana']\n\n self.assertRaises(\n ValueError,\n setSlope\n )","def initializeWeightsToZero(self):\n\t\t## YOUR CODE BELOW\n\t\t\n\t\tutil.raiseNotDefined()\n\t\treturn","def is_zero(self):\n return -0.0001 <= self.l2_norm() <= 0.0001","def test_Sobol_G_raises_error_if_values_lt_zero():\n with raises(ValueError):\n evaluate(np.array([0, -1, -.02, 1, 1, -0.1, -0, -12]))","def slope(l):\n if l[1] == l[0]:\n return float(\"inf\")\n else:\n return float(l[3]-l[2])/(l[1]-l[0])","def model_fixed_slope(train_x, train_y, test_x, slope=1):\n intercept = np.mean(train_y - train_x*slope)\n model_info = {'model': 'fixed_slope', 'const': intercept}\n predictions = test_x*slope + intercept\n return predictions, model_info","def test__validate_with_synthetic_data_plus_noise(elbow_with_synthetic_data):\n # Test with an odd number of points\n x, y, break_pt = elbow_with_synthetic_data\n np.random.seed(12)\n range = (y.max() - y.min()) * 0.02\n y = y + np.random.randn(y.shape[0]) * range\n expected_elbow = np.argmin(np.abs(x - break_pt))\n found_elbow = find_elbow_point(x, y)\n assert abs(found_elbow - expected_elbow) < 10\n\n # Test with an even number of points\n x, y, break_pt = elbow_with_synthetic_data\n range = (y.max() - y.min()) * 0.02\n y = y + np.random.randn(y.shape[0]) * range\n expected_elbow = np.argmin(np.abs(x - break_pt))\n found_elbow = find_elbow_point(x, y, max_iter=40)\n assert abs(found_elbow - expected_elbow) < 10","def test_linear_binomial_fails_leading_zero(self):\n self.assertRaises(ValueError, LinearBinomial, 0, 1)","def baseline_deviation_1_rule(_m, y):\r\n\r\n if y == m.Y.first():\r\n return Constraint.Skip\r\n else:\r\n return m.z_b1[y] >= m.baseline[y] - m.baseline[y - 1]","def _no_reg(self, y, x, y_minus_g, w_0):\n # Initialize weight vector to return\n w_1 = np.zeros(len(w_0))\n \n ascent = self._epsilon * y_minus_g\n \n for j in range(len(x)):\n w_1[j] = w_0[j] + x[j]*ascent\n \n return w_1","def testSlopeDefault(self):\n self.assertEqual(\n (Decimal('1.0'), Decimal('1.0'), Decimal('1.0')),\n self.node.slope\n )","def handle_slopes(self, slopeG):\n\n\n\n colSprite = pygame.sprite.spritecollideany(self, slopeG)\n if colSprite: #and self.rect.y < colSprite.rect.y:\n self.fall = False\n\n tl = colSprite.rect.topleft # used for slope calculation only\n br = colSprite.rect.bottomright\n\n m1 = float((br[1]-tl[1])/(br[0]-tl[0])) # y2-y1/(x2-x1)\n angle_rad = math.atan(m1) # from atan(m1 - m1 /(1+m1m2))\n # The angle is normally 45 degrees\n\n if self.x_vel:\n #le = self.x_vel / abs(self.x_vel) * 4\n le = self.x_vel\n else:\n le = 0\n\n x_move_len = le\n y_move_len = self.calc_vertical(x_move_len, angle_rad)\n\n # just for debugging\n self.d1 = x_move_len\n self.d2 = y_move_len\n\n # Now, it is needed to move the player down till\n # he reaches the 'essence' of the slope. This is because I\n # am too lazy to implement pixel-perfect collision.\n # Since this is to be done only once, a variable will be used\n # to keep track of whether this has beend donef for one slope or not\n\n # tolerance for height changing\n tol = False\n if abs(colSprite.rect.topleft[1] - self.rect.bottomleft[1]) <= 10:\n tol = True\n #print \"ABS \", abs(colSprite.rect.topleft[1] - self.rect.bottomleft[1])\n\n if not self.prev_slope and tol:\n self.prev_slope = True\n\n x_off_mov = colSprite.rect.topleft[0] - self.rect.bottomleft[0]\n y_off_mov = self.calc_vertical(x_off_mov, angle_rad)\n\n # handling for rightwards velocity\n if self.direction == RIGHT:\n y_off_mov = -y_off_mov\n\n\n self.rect.move_ip((0, y_off_mov))\n\n # check collision with any slope\n\n #self.rect.move_ip((x_move_len, y_move_len))\n # it seems that the above code is redundant; will check\n self.rect.move_ip((-self.x_vel, 0)) # undo the shifting\n self.rect.move_ip((x_move_len, y_move_len))\n\n else:\n self.prev_slope = False","def calculate_y(y0,ey,ymax,PBC=True):\r\n\ty = y0 + dt*np.cumsum(ey)\r\n\twhile (y>ymax).any() or (y<0.0).any():\r\n\t\tidg = (y>ymax)\r\n\t\ty[idg] = 2*ymax - y[idg] if PBC else ymax\r\n\t\tidl = (y<0.0)\r\n\t\ty[idl] *= -1.0\r\n\treturn y","def test_is_valid_fujita_rating_ef_leading_zero(self):\n\n self.assertTrue(\n tornado_io._is_valid_fujita_rating(EF_SCALE_RATING_LEADING_ZERO)\n )","def test_nans_in_x_data(self):\n alpha = 0.9\n num_x = 150\n num_y = 100\n x_vals = np.linspace(0, 2 * np.pi, num_x)\n x_vals[45] = np.nan\n y_vals = (np.sin(x_vals[:num_y]) + 0.3 * np.random.randn(num_y) + 0.5)\n\n with pytest.raises(RuntimeError):\n extrapolated_lowess(x_vals, y_vals, alpha=alpha)","def smooth_negative_labels(y):\n return y + (np.random.random(y.shape) * 0.1)","def test_zero(self):\n controller = LinearController(self.G, 2, mode='zero')\n sim = simulation.Simulation(self.G, controller, dt=self.dt)\n sim.run(self.dt)\n\n self.assertAlmostEqual(np.linalg.norm(controller.W.ravel()), 0.0)\n self.assertAlmostEqual(np.linalg.norm(controller.out), 0.0)","def zero_crossings(x):\n return np.array(np.where(np.diff(np.sign(x)))[0])","def __init__(self):\n self.slope = -1.0\n self.last_obs = -1.0\n self.last_obs_ind = -1\n self._fitted = False","def _correct_coefs(coefs):\n coefs = coefs.copy().flatten()\n coefs[coefs < 0] = 0\n coefs /= coefs.sum() # Normalize to sum to 1\n return coefs","def absolute_trick(bias, slope, predictor, current_value, learning_rate):\n predicted_value = bias + slope*predictor\n if current_value > predicted_value:\n slope += learning_rate*predictor\n bias += learning_rate\n else:\n slope -= learning_rate*predictor\n bias -= learning_rate\n return slope, bias","def test_find_append_zero_crossings():\n x = np.arange(11) * units.hPa\n y = np.array([3, 2, 1, -1, 2, 2, 0, 1, 0, -1, 2]) * units.degC\n x2, y2 = _find_append_zero_crossings(x, y)\n\n x_truth = np.array([0., 1., 2., 2.4494897, 3., 3.3019272, 4., 5.,\n 6., 7., 8., 9., 9.3216975, 10.]) * units.hPa\n y_truth = np.array([3, 2, 1, 0, -1, 0, 2, 2, 0, 1, 0, -1, 0, 2]) * units.degC\n assert_array_almost_equal(x2, x_truth, 6)\n assert_almost_equal(y2, y_truth, 6)","def _test5():\n# import matplotlib.pyplot as plt\n from math import pi, cos, sin\n n = 800\n PI2 = 2.0*pi\n angle = PI2 / n\n pts = []\n r = 10.0\n for i in range(n):\n beta = i * angle\n x = r*cos(beta)\n y = r*sin(beta)\n pts.append((x, y))\n print (regress(pts))\n are_zero = are_residuals_near_zero(pts)","def fixed_baseline(random_seeds, train_data, test_data):\n\n err = 0.\n\n for seed in random_seeds:\n np.random.seed(seed)\n\n data = prep_data(train_data, test_data)\n\n wrong = 0.\n for i in range(data['test_rows']):\n if not data['test_ys'][i] == 1.0:\n wrong += 1\n\n err += wrong / data['test_rows']\n\n return err / len(random_seeds)","def test_init_vals_length_error_in_fit_mle(self):\n # Note there is only one beta, so we can't go lower than zero betas.\n original_intercept_ref_position = self.fake_intercept_ref_pos\n for intercept_ref_position in [None, original_intercept_ref_position]:\n self.base_clog.intercept_ref_position = intercept_ref_position\n for i in [1, -1]:\n # This will ensure we have too many or too few intercepts\n num_coefs = self.fake_betas.shape[0] + i\n\n # Test to ensure that the ValueError when using an\n # init_intercepts kwarg with an incorrect number of parameters\n self.assertRaisesRegexp(ValueError,\n \"dimension\",\n self.base_clog.fit_mle,\n np.arange(num_coefs),\n print_res=False)\n\n return None","def model_fun(params, slope, x):\n w = params['w']\n t0 = params['t0']\n offset = params['offset']\n return offset + slope * jax.nn.sigmoid(jnp.dot(x, w) - t0)","def test_zero_degree_polynomial(cls):\n\n MESSAGE = \"Degree of polynomial must be positive or null\"\n\n if cls.n_inputs == 1: # Test 1D polynomials\n p1 = cls(degree=0, c0=1)\n assert p1(0) == 1\n assert np.all(p1(np.zeros(5)) == np.ones(5))\n\n x = np.linspace(0, 1, 100)\n # Add a little noise along a straight line\n y = 1 + np.random.uniform(0, 0.1, len(x))\n\n p1_init = cls(degree=0)\n fitter = fitting.LinearLSQFitter()\n p1_fit = fitter(p1_init, x, y)\n\n # The fit won't be exact of course, but it should get close to within\n # 1%\n assert_allclose(p1_fit.c0, 1, atol=0.10)\n\n # Error from negative degree\n with pytest.raises(ValueError, match=MESSAGE):\n cls(degree=-1)\n elif cls.n_inputs == 2: # Test 2D polynomials\n if issubclass(cls, OrthoPolynomialBase):\n p2 = cls(x_degree=0, y_degree=0, c0_0=1)\n\n # different shaped x and y inputs\n a = np.array([1, 2, 3])\n b = np.array([1, 2])\n with mk.patch.object(\n PolynomialBase,\n \"prepare_inputs\",\n autospec=True,\n return_value=((a, b), mk.MagicMock()),\n ):\n with pytest.raises(\n ValueError, match=r\"Expected input arrays to have the same shape\"\n ):\n p2.prepare_inputs(mk.MagicMock(), mk.MagicMock())\n\n # Error from negative degree\n with pytest.raises(ValueError, match=MESSAGE):\n cls(x_degree=-1, y_degree=0)\n with pytest.raises(ValueError, match=MESSAGE):\n cls(x_degree=0, y_degree=-1)\n else:\n p2 = cls(degree=0, c0_0=1)\n\n # Error from negative degree\n with pytest.raises(ValueError, match=MESSAGE):\n cls(degree=-1)\n\n assert p2(0, 0) == 1\n assert np.all(p2(np.zeros(5), np.zeros(5)) == np.ones(5))\n\n y, x = np.mgrid[0:1:100j, 0:1:100j]\n z = (1 + np.random.uniform(0, 0.1, x.size)).reshape(100, 100)\n\n if issubclass(cls, OrthoPolynomialBase):\n p2_init = cls(x_degree=0, y_degree=0)\n else:\n p2_init = cls(degree=0)\n fitter = fitting.LinearLSQFitter()\n p2_fit = fitter(p2_init, x, y, z)\n\n assert_allclose(p2_fit.c0_0, 1, atol=0.10)","def y_axis_left_zero(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"y_axis_left_zero\")","def init_standard_poly(basetensor, ind, x):\n ind.zeroAllBut(0, 0)\n basetensor[ind.all+ind.getCurrent()] = 1.\n for i in range(x.shape[1]):\n ind.zeroAllBut(i, 1)\n basetensor[ind.all + ind.getCurrent()] = x[:, i]","def aerosols(self):\n return 1.","def calc_error(self):\n if self._fit_data.y is not None and self._fit_data.y_fit is not None:\n self._fit_data.error_vector = self._fit_data.y - self._fit_data.y_fit","def zero_calibrationn(self):\n self.link.write(self._calibrateZeroSequence)","def zero_crossings(y_axis, window = 11):\n # smooth the curve\n length = len(y_axis)\n x_axis = np.asarray(range(length), int)\n \n # discard tail of smoothed signal\n y_axis = _smooth(y_axis, window)[:length]\n zero_crossings = np.where(np.diff(np.sign(y_axis)))[0]\n indices = [x_axis[index] for index in zero_crossings]\n \n # check if zero-crossings are valid\n diff = np.diff(indices)\n if diff.std() / diff.mean() > 0.2:\n print diff.std() / diff.mean()\n print np.diff(indices)\n raise(ValueError, \n \"False zero-crossings found, indicates problem {0} or {1}\".format(\n \"with smoothing window\", \"problem with offset\"))\n # check if any zero crossings were found\n if len(zero_crossings) < 1:\n raise(ValueError, \"No zero crossings found\")\n \n return indices \n # used this to test the fft function's sensitivity to spectral leakage\n #return indices + np.asarray(30 * np.random.randn(len(indices)), int)\n # Calculate X profile for page split","def accuracy_on_zero(y_true, y_pred):\n \n y_true_flipped = 1 - y_true\n y_pred_flipped = 1- y_pred\n \n sum_true_negatives = K.sum(K.round(K.clip( y_true_flipped * y_pred_flipped, 0, 1)))\n \n sum_all_negatives = K.sum(K.round(K.clip(y_true_flipped, 0, 1)))\n \n acc_on_zero = sum_true_negatives / (sum_all_negatives + K.epsilon())\n return acc_on_zero","def leoGiddingsFit(self,zeroX_to_LEO_limit,calib_zeroX_to_peak,calib_gauss_width):\r\n\r\n\t\t#run the scatteringPeakInfo method to retrieve various peak attributes \r\n\t\tself.scatteringPeakInfo()\r\n\t\t\r\n\t\t#get the baseline\r\n\t\tbaseline = self.scatteringBaseline\r\n\t\t\r\n\t\t#get the zero-crossing for the particle\r\n\t\tzero_crossing_pt_LEO = self.zeroCrossing(evap_threshold)\r\n\t\t\r\n\t\tif zero_crossing_pt_LEO < 0: #ie we can't find the zero crossing\r\n\t\t\tself.LF_scattering_amp = -2\r\n\t\t\tself.LF_baseline = -2\r\n\t\t\tself.LF_results = []\r\n\t\t\tself.LF_max_index = -2\r\n\t\t\tself.beam_center_pos = -2\r\n\t\t\t\r\n\t\telse:\r\n\t\t\t#LEO max index sets the x-limit for fitting based on the desired magnification factor\r\n\t\t\tLEO_max_index = int(round(zero_crossing_pt_LEO-zeroX_to_LEO_limit))\r\n\t\t\r\n\t\t\tself.LF_max_index = LEO_max_index\r\n\t\t\tLEO_min_index = 0\r\n\t\t\t\r\n\t\t\tx_vals_all = np.array(self.getAcqPoints()) + 1 #avoids divide by zero in Giddings fit\r\n\t\t\tself.LF_x_vals_to_use = x_vals_all[LEO_min_index:LEO_max_index]\r\n\r\n\t\t\ty_vals_all = np.array(self.getScatteringSignal())\r\n\t\t\tself.LF_y_vals_to_use = y_vals_all[LEO_min_index:LEO_max_index]\r\n\r\n\t\t\tself.beam_center_pos = zero_crossing_pt_LEO-calib_zeroX_to_peak\r\n\t\t\t\t\t\t\t\r\n\t\t\tdef LEOGiddings(x, a):\r\n\t\t\t\t# Note: scipy.special.iv is the modified Bessel function of the first kind\r\n\t\t\t\treturn baseline + (a/calib_gauss_width)*np.sqrt(self.beam_center_pos/x)*(scipy.special.iv(0,(2*np.sqrt(self.beam_center_pos*x)/calib_gauss_width))) * np.exp((-x-self.beam_center_pos)/calib_gauss_width)\r\n\r\n\t\t\t#run the fitting\r\n\t\t\ttry:\r\n\t\t\t\tpopt, pcov = curve_fit(LEOGiddings, self.LF_x_vals_to_use, self.LF_y_vals_to_use)\r\n\t\t\texcept:\r\n\t\t\t\tpopt, pcov = [-1], [np.nan] \r\n\t\r\n\r\n\t\t\tfit_result = []\r\n\t\t\tfor x in x_vals_all:\r\n\t\t\t\tfit_result.append(LEOGiddings(x,popt[0]))\r\n\t\t\tself.LF_results = fit_result\r\n\t\t\tself.LF_scattering_amp = np.max(fit_result)-baseline#popt[0] \r\n\t\t\tself.LF_baseline = np.nan","def hinge(datax,datay,w):\n #hinge: si bien classifie, -y<0 sinon >0. On ne compte celui sont mal-classifies\n fx = np.dot(datax, w.T)\n return np.mean(np.where(-datay*fx<0,0,-datay*fx))","def fun(params, slope, data):\n x, y_true = data\n return y_true - model_fun(params, slope, x)","def zero_crosser(indicator: pd.Series) -> pd.Series:\n indicator = indicator.fillna(0)\n return (((indicator.shift() * indicator) <= 0) * np.sign(indicator)).astype(int)","def testAlphaZeroNllsMatchACauchyDistribution(self):\n x = jnp.linspace(-10, 10, 1000)\n scale = 1.7\n nll = self.variant(self._distribution.nllfun)(x, 0, scale)\n nll_true = -scipy.stats.cauchy(0, scale * jnp.sqrt(2)).logpdf(x)\n chex.assert_tree_all_close(nll, nll_true, atol=1e-5, rtol=1e-5)","def zzX_zero_of(f, d=0):\n return zzX_zero(poly_level(f)-d)","def update_weights_negative(self):\n eta = self.config.eta\n self.w_xh -= eta * (self.x.T @ self.h)\n self.w_th -= eta * (self.t.T @ self.h)\n self.w_ho -= eta * (self.h.T @ self.o) \n self.w_hz -= eta * (self.h.T @ self.z)","def test_y0_provided(self):\r\n dev = qml.device(\"default.qubit\", wires=2)\r\n\r\n with qml.tape.JacobianTape() as tape:\r\n qml.RX(0.543, wires=[0])\r\n qml.RY(-0.654, wires=[0])\r\n qml.expval(qml.PauliZ(0))\r\n\r\n f0 = dev.execute(tape)\r\n tapes, fn = finite_diff(tape, approx_order=1, f0=f0)\r\n\r\n # one tape per parameter, plus one global call\r\n assert len(tapes) == tape.num_params","def linear_slope_fit(wf, mean_y, sigma_y, slope, intercept):\n\n sum_x = sum_x2 = sum_xy = sum_y = mean_y[0] = sigma_y[0] = 0\n isum = len(wf)\n\n for i,value in enumerate(wf):\n sum_x += i \n sum_x2 += i**2\n sum_xy += (value * i)\n sum_y += value\n mean_y += (value-mean_y) / (i+1)\n sigma_y += (value-mean_y)**2\n\n\n sigma_y /= (isum + 1)\n np.sqrt(sigma_y, sigma_y)\n\n\n slope[0] = (isum * sum_xy - sum_x * sum_y) / (isum * sum_x2 - sum_x * sum_x)\n intercept[0] = (sum_y - sum_x * slope[0])/isum","def e0_xy_correction(map : ASectorMap ,\n norm_strat : norm_strategy = norm_strategy.max):\n normalization = get_normalization_factor(map , norm_strat)\n get_xy_corr_fun = maps_coefficient_getter (map.mapinfo, map.e0)\n def geo_correction_factor(x : np.array,\n y : np.array) -> np.array:\n return correct_geometry_(get_xy_corr_fun(x,y))* normalization\n return geo_correction_factor","def y0(self):\n return self._y0","def y0(self):\n return self.params['y0']","def test_wrong_gradients_raises_assertion(self):\n model = PoincareModel(self.data, negative=3)\n model._loss_grad = Mock(return_value=np.zeros((2 + model.negative, model.size)))\n with self.assertRaises(AssertionError):\n model.train(epochs=1, batch_size=1, check_gradients_every=1)","def __init__(self, neg_slope):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n\n\n self.neg_slope = neg_slope\n\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def test_init_intercepts_length_error_in_fit_mle(self):\n # Create a variable for the arguments to the fit_mle function.\n # Note `None` is the argument passed when using the init_intercepts\n # and init_coefs keyword arguments.\n fit_args = [None]\n\n # Create base set of kwargs for fit_mle function\n kwargs = {\"init_coefs\": self.fake_betas,\n \"print_res\": False}\n\n for i in [1, -1]:\n # This will ensure we have too many or too few intercepts\n num_intercepts = self.fake_intercepts.shape[0] + i\n kwargs[\"init_intercepts\"] = np.arange(num_intercepts)\n\n # Test to ensure that the ValueError is raised when using an\n # init_intercepts kwarg with an incorrect number of parameters\n self.assertRaises(ValueError, self.base_clog.fit_mle,\n *fit_args, **kwargs)\n\n return None","def test_zero_bootstrapping(self, num_classes: int):\n\n loss_fn = single_index.XentLoss(num_classes)\n batch_size = 4\n batch = base.Batch(\n x=np.expand_dims(np.arange(batch_size), 1),\n y=np.random.random_integers(0, num_classes - 1, size=(batch_size, 1)),\n data_index=np.expand_dims(np.arange(batch_size), 1),\n weights=np.zeros([batch_size, 1]),\n )\n\n # Test when apply always return a uniform distribution over labels\n apply = lambda p, x, i: np.ones(shape=(x.shape[0], num_classes))\n loss, unused_metrics = loss_fn(\n apply=apply, params=self._params, batch=batch, index=self._index)\n self.assertEqual(\n loss, 0.0, ('expected loss with zero bootstrapping weights to be zero, '\n f'but it is {loss}'))","def fit_slope_1d(X,Y):\n Sx = np.sum(X)\n Sy = np.sum(Y)\n Sxx = np.sum(np.power(X,2))\n Sxy = np.sum(X*Y)\n Syy = np.sum(np.power(Y,2)) \n n = len(X)*1.\n slope = (n*Sxy - Sx*Sy)/(n*Sxx-Sx**2)\n alpha = Sy/n - slope*Sx/n\n return slope, alpha","def calculate_zero_cross_rate(series):\n series_mean = np.mean(series)\n series = [v - series_mean for v in series]\n zero_cross_count = (np.diff(np.sign(series)) != 0).sum()\n return zero_cross_count / len(series)","def test__repeated_median_catch_division_by_zero(repeated_median):\n *_, divzero_x, divzero_y = repeated_median\n assert repeated_median_slope(divzero_x, divzero_y) == 1.0","def __init__(self, neg_slope):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n self.neg_slope = neg_slope\n self.input_cache = None\n ########################\n # END OF YOUR CODE #\n #######################","def NoisySlope(x,y, dx, plot=None):\n # compute slopes\n slopes = []\n synth = np.zeros(len(x))\n x0 = x[0]\n xmax = x.max()\n\n # default slope\n def_slope = (y[-1]-y[0])/(x[-1]-x[0])\n while x0+dx=x0)*(x<=x0+dx))\n if len(w[0])>10:\n coef = np.polyfit(x[w]-x[w].mean(), y[w], 1)\n slopes.append(coef[0])\n synth[w] = np.polyval(coef, x[w]-x[w].mean())\n else:\n if len(w[0])>0:\n synth[w] = y[w][0]+def_slope*(x[w]-x[w][0])\n x0 += dx\n\n # sigma clipping\n slopes = np.array(slopes)\n t = np.linspace(slopes.min(), slopes.max(), 500)\n s = slopes.argsort()\n slopes = slopes[s]\n r = slopes[int(len(slopes)*.7)]-slopes[int(len(slopes)*.3)]\n w = np.where((slopes>=(np.median(slopes)-2*r))*\\\n (slopes<=(np.median(slopes)+2*r)))\n guess = [0.0, 0.0, np.median(slopes), r]\n best = myfit.fit(myfit.erf, slopes[w], guess, \\\n np.linspace(0,1,len(slopes))[w])\n best = best.leastsqfit()\n\n plt.figure(20)\n plt.clf()\n plt.plot(slopes*1e6, np.linspace(0,1,len(slopes)), 'ob')\n plt.plot(slopes[w]*1e6, np.linspace(0,1,len(slopes))[w], 'or')\n plt.plot(t*1e6, myfit.erf(t,best), 'r', linewidth=2)\n plt.xlim((best[2]-5*best[3])*1e6,\\\n (best[2]+5*best[3])*1e6)\n plt.xlabel('slope (um/s)')\n\n return (best[2],best[3], synth)","def zero_norm(arr):\n arr = 2 * (arr - min(arr)) / (max(arr) - min(arr)) - 1\n return arr - np.sum(arr) / len(arr)","def test_PredictionEnsemble_smooth_None(\r\n perfectModelEnsemble_initialized_control_1d_ym_cftime,\r\n):\r\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\r\n pm_smoothed = pm.smooth(None)\r\n assert_PredictionEnsemble(pm, pm_smoothed)","def formula_0(x: np.ndarray) -> np.ndarray:\n logx = np.log(x)\n denom = x - 1\n k0 = (x - logx * x - 1) / denom\n return k0"],"string":"[\n \"def fit_slope_with_zero_intercept_residue(X,Y):\\n X = np.array(X)\\n Y = np.array(Y)\\n slope = np.sum(Y*X)/np.sum(np.power(X,2))\\n return slope*X - Y\",\n \"def zeroCrossing(self,evap_threshold):\\r\\n\\t\\tself.splitBaseline =(np.mean(self.splitData[0:10]))\\t\\r\\n\\t\\tsplit_max_index = np.argmax(self.splitData)\\r\\n\\t\\tsplit_min_index = np.argmin(self.splitData)\\r\\n\\r\\n\\t\\tif split_max_index >= split_min_index:\\r\\n\\t\\t\\treturn self.zeroCrossingPosSlope(evap_threshold)\\r\\n\\t\\t\\r\\n\\t\\tif split_max_index < split_min_index:\\r\\n\\t\\t\\treturn self.zeroCrossingNegSlope(evap_threshold)\",\n \"def leakyrelu(x, negative_slope: float = 0.01):\\n return np.max(x, 0) + negative_slope * np.min(-x, 0)\",\n \"def zeroCrossingNegSlope(self, evap_threshold):\\r\\n\\t\\tself.splitBaseline = np.mean(self.splitData[0:10])\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tsplit_min_index = np.argmin(self.splitData)\\r\\n\\t\\t\\tsplit_max_index = np.argmax(self.splitData[0:split_min_index])\\r\\n\\t\\t\\tsplit_max_value = self.splitData[split_max_index]\\r\\n\\t\\t\\tsplit_min_value = self.splitData[split_min_index]\\r\\n\\t\\texcept:\\r\\n\\t\\t\\tzero_crossing = -3\\r\\n\\t\\t\\treturn zero_crossing\\r\\n\\t\\t#print 'split',\\tsplit_min_index, (self.splitBaseline-split_min_value), split_max_index,(split_max_value-self.splitBaseline)\\r\\n\\t\\tif (self.splitBaseline-split_min_value) >= evap_threshold and (split_max_value-self.splitBaseline) >= evap_threshold: #avoid particles evaporating before the notch position can be properly determined (details in Taylor et al. 10.5194/amtd-7-5491-2014)\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tfor index in range(split_max_index, split_min_index+1): #go to max +1 because 'range' function is not inclusive\\r\\n\\t\\t\\t\\t\\tif self.splitData[index] > self.splitBaseline:\\r\\n\\t\\t\\t\\t\\t\\tvalue_zero_cross_pos = float(self.splitData[index])\\r\\n\\t\\t\\t\\t\\t\\tindex_zero_cross_pos = index\\r\\n\\t\\t\\t\\t\\tif self.splitData[index] <= self.splitBaseline:\\r\\n\\t\\t\\t\\t\\t\\tvalue_zero_cross_neg = float(self.splitData[index])\\r\\n\\t\\t\\t\\t\\t\\tindex_zero_cross_neg = index\\r\\n\\t\\t\\t\\t\\t\\tbreak\\r\\n\\t\\t\\t\\tzero_crossing = index+((value_zero_cross_pos-self.splitBaseline)*(index_zero_cross_pos-index_zero_cross_neg))/(value_zero_cross_pos-value_zero_cross_neg) \\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tzero_crossing = -1\\r\\n\\t\\t\\r\\n\\t\\telse: \\r\\n\\t\\t\\tzero_crossing = -2\\r\\n\\r\\n\\t\\tself.zeroCrossingPos = zero_crossing\\r\\n\\t\\treturn zero_crossing\",\n \"def zeroCrossingPosSlope(self, evap_threshold):\\r\\n\\t\\tself.splitBaseline = np.mean(self.splitData[0:10])\\r\\n\\t\\tsplit_max_index = np.argmax(self.splitData)\\r\\n\\t\\tsplit_min_index = np.argmin(self.splitData[0:split_max_index])\\r\\n\\t\\tsplit_max_value = self.splitData[split_max_index]\\r\\n\\t\\tsplit_min_value = self.splitData[split_min_index]\\r\\n\\r\\n\\t\\tif (self.splitBaseline-split_min_value) >= evap_threshold and (split_max_value-self.splitBaseline) >=evap_threshold: #avoid particles evaporating before the notch position can be properly determined (details in Taylor et al. 10.5194/amtd-7-5491-2014)\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tfor index in range(split_min_index, split_max_index+1): #go to max +1 because 'range' function is not inclusive\\r\\n\\t\\t\\t\\t\\tif self.splitData[index] < self.splitBaseline:\\r\\n\\t\\t\\t\\t\\t\\tvalue_zero_cross_neg = float(self.splitData[index])\\r\\n\\t\\t\\t\\t\\t\\tindex_zero_cross_neg = index\\r\\n\\t\\t\\t\\t\\tif self.splitData[index] >= self.splitBaseline:\\r\\n\\t\\t\\t\\t\\t\\tvalue_zero_cross_pos = float(self.splitData[index])\\r\\n\\t\\t\\t\\t\\t\\tindex_zero_cross_pos = index\\r\\n\\t\\t\\t\\t\\t\\tbreak\\r\\n\\t\\t\\t\\tzero_crossing = index+((value_zero_cross_pos-self.splitBaseline)*(index_zero_cross_pos-index_zero_cross_neg))/(value_zero_cross_pos-value_zero_cross_neg) \\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tzero_crossing = -1 \\r\\n\\t\\t\\t\\t\\r\\n\\t\\telse:\\r\\n\\t\\t\\tzero_crossing = -2 \\r\\n\\t\\t\\r\\n\\t\\tself.zeroCrossingPos = zero_crossing\\r\\n\\t\\treturn zero_crossing\",\n \"def testSlopeSetNegative(self):\\n def setSlope():\\n self.cc.slope = [-1.3782, 278.32, 0.738378233782]\\n\\n cdl_convert.config.HALT_ON_ERROR = True\\n\\n self.assertRaises(\\n ValueError,\\n setSlope\\n )\\n\\n cdl_convert.config.HALT_ON_ERROR = False\\n\\n setSlope()\\n\\n self.assertEqual(\\n (Decimal('0.0'), Decimal('278.32'), Decimal('0.738378233782')),\\n self.cc.slope\\n )\",\n \"def testSlopeSetNegative(self):\\n def setSlope():\\n self.node.slope = [-1.3782, 278.32, 0.738378233782]\\n\\n cdl_convert.config.HALT_ON_ERROR = True\\n\\n self.assertRaises(\\n ValueError,\\n setSlope\\n )\\n\\n cdl_convert.config.HALT_ON_ERROR = False\\n\\n setSlope()\\n\\n self.assertEqual(\\n (Decimal('0.0'), Decimal('278.32'), Decimal('0.738378233782')),\\n self.node.slope\\n )\",\n \"def test_positive_slope(self):\\n slopes = []\\n for i in range(100):\\n neighborhood, pc = create_point_cloud_in_plane_and_neighborhood()\\n slopes += list(EigenValueVectorizeFeatureExtractor().extract(pc, neighborhood, None, None, None)[6])\\n np.testing.assert_array_less(np.zeros_like(slopes), slopes)\",\n \"def find_zero_cross(x, y):\\r\\n\\r\\n try:\\r\\n zp = np.where(y[:-1] * y[1:] <= 0)[0][0] #make a list of A[x] * A[x -1] without usinf \\\"for\\\" loop in original python.\\r\\n m = np.polyfit(x[(zp - 1):(zp + 1)], y[(zp -1):(zp + 1)], 1)\\r\\n zc = -m[1]/m[0] #For y = ax + b and y = 0, then x = -b/a.\\r\\n\\r\\n except:\\r\\n print 'error at zero_cross'\\r\\n zc = 0\\r\\n\\r\\n return zc\",\n \"def calculate_edges_zero(self, verbose = False):\\n\\n ## calculates the first and last wavelength that has non-zero\\n # w = np.where(self.throughput > 0)[0]\\n # if verbose: print(w)\\n # self._upper_edge = self.wavelength[w[-1]]\\n # self._lower_edge = self.wavelength[w[0]]\\n\\n w = np.where(self.throughput > 0)[0]\\n if verbose: print(w)\\n if w[0] - 1 < 0:\\n w_low = 0\\n else:\\n w_low = w[0] - 1\\n\\n if w[-1] + 1 == len(self.throughput):\\n w_high = w[-1]\\n else:\\n w_high = w[-1] + 1\\n\\n self._upper_edge = self.wavelength[w_high]\\n self._lower_edge = self.wavelength[w_low]\",\n \"def test_check_null_weight_with_zeros() -> None:\\n sample_weight = np.ones_like(y_toy)\\n sample_weight[:1] = 0.0\\n sw_out, X_out, y_out = check_null_weight(sample_weight, X_toy, y_toy)\\n np.testing.assert_almost_equal(sw_out, np.array([1, 1, 1, 1, 1]))\\n np.testing.assert_almost_equal(X_out, np.array([[1], [2], [3], [4], [5]]))\\n np.testing.assert_almost_equal(y_out, np.array([7, 9, 11, 13, 15]))\",\n \"def slope(self):\\n if self.b == 0:\\n return None\\n else:\\n return (-1) * self.a/self.b\",\n \"def testSetSlopeWithNegativeInt(self):\\n def setSlope():\\n self.node.slope = -20\\n\\n cdl_convert.config.HALT_ON_ERROR = True\\n\\n self.assertRaises(\\n ValueError,\\n setSlope\\n )\\n\\n cdl_convert.config.HALT_ON_ERROR = False\\n\\n setSlope()\\n\\n self.assertEqual(\\n (Decimal('0.0'), Decimal('0.0'), Decimal('0.0')),\\n self.node.slope\\n )\",\n \"def slope(a, b):\\r\\n if a[0] == b[0]: #If the x values are both 0\\r\\n return 0 #Technically, undefined, but doesn't matter for finding collinearity\\r\\n return (a[1] - b[1]) / (a[0] - b[0])\",\n \"def test__validate_with_synthetic_data(elbow_with_synthetic_data):\\n x, y, break_pt = elbow_with_synthetic_data\\n expected_elbow = np.argmin(np.abs(x - break_pt))\\n assert expected_elbow == find_elbow_point(x, y)\",\n \"def testSetSlopeWithNegativeFloat(self):\\n def setSlope():\\n self.node.slope = -20.1\\n\\n cdl_convert.config.HALT_ON_ERROR = True\\n\\n self.assertRaises(\\n ValueError,\\n setSlope\\n )\\n\\n cdl_convert.config.HALT_ON_ERROR = False\\n\\n setSlope()\\n\\n self.assertEqual(\\n (Decimal('0.0'), Decimal('0.0'), Decimal('0.0')),\\n self.node.slope\\n )\",\n \"def test_non_linear_fit_zero_degree_polynomial_with_weights(fitter):\\n\\n model = models.Polynomial1D(0, c0=0)\\n fitter = fitter()\\n\\n x = np.arange(10, dtype=float)\\n y = np.ones((10,))\\n weights = np.ones((10,))\\n\\n fit = fitter(model, x, y)\\n assert_almost_equal(fit.c0, 1.0)\\n\\n fit = fitter(model, x, y, weights=weights)\\n assert_almost_equal(fit.c0, 1.0)\",\n \"def loss_piecewise(y, a):\\n if not y: # Runs if y == 0\\n return -1 * np.log10(1 - a)\\n else: # Runs if y != 0\\n return -1 * np.log10(a)\",\n \"def asymtotic_approx(self, zero_crossings):\\n x = np.sqrt(2 * np.log(zero_crossings))\\n return x + 0.5772 / x\",\n \"def test_null_bootstrapping(self):\\n\\n apply = lambda p, x, i: x[:, :1]\\n output = apply(self._params, self._batch.x, self._index)\\n # y is zero, hence the loss is just the mean square of the output.\\n expected_loss = np.mean(np.square(output))\\n\\n loss_fn = single_index.L2Loss()\\n loss, unused_metrics = loss_fn(\\n apply=apply, params=self._params, batch=self._batch, index=self._index)\\n self.assertEqual(\\n loss, expected_loss,\\n (f'expected loss with null bootstrapping is {expected_loss}, '\\n f'but it is {loss}'))\",\n \"def findzero(x,y):\\n\\t\\targs = np.where(y > 0)[0]\\n\\t\\tif len(args) == 0:\\n\\t\\t\\tprint \\\"Unable to find zero! Using maximum T.\\\"\\n\\t\\t\\ti = len(y) - 1\\n\\t\\telse:\\n\\t\\t\\ti = min(args)\\n\\n\\t\\t#Do a fit using the surrounding points, and perform interpolation based on that\\n\\t\\tp = np.polyfit(x[i-1:i+1],y[i-1:i+1],1)\\n\\t\\tyfit = p[0]*x[i-1:i+1] + p[1]\\n\\t\\tf = interp.interp1d(yfit, x[i-1:i+1])\\n\\t\\treturn float(f(0))\",\n \"def test_non_zero_loss(self):\\n # Reset models.\\n self.model.load_state_dict(self.initial_model_dict)\\n self.actor_model.load_state_dict(self.initial_actor_model_dict)\\n\\n polybeast.learn(*self.learn_args)\\n\\n self.assertNotEqual(self.stats[\\\"total_loss\\\"], 0.0)\\n self.assertNotEqual(self.stats[\\\"pg_loss\\\"], 0.0)\\n self.assertNotEqual(self.stats[\\\"baseline_loss\\\"], 0.0)\\n self.assertNotEqual(self.stats[\\\"entropy_loss\\\"], 0.0)\",\n \"def test_intra_power_law_fit_no_model(self):\\n\\n\\t\\tdetails= self.watcher.analyze(model=self.model, layers=self.fc_layers, intra=True, randomize=False, vectors=False)\\n\\t\\tactual_alpha = details.alpha[0]\\n\\n\\t\\texpected_alpha = 2.654 # not very accurate because of the sparisify transform\\n\\t\\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=1)\",\n \"def test_elbo_loss(self):\\n\\n batch_size = 4\\n batch = base.Batch(\\n x=np.expand_dims(np.arange(batch_size), 1),\\n y=np.arange(batch_size),\\n )\\n params = dict()\\n apply = lambda p, x, i: x[:, 0]\\n index = np.array([])\\n output = apply(params, batch.x, index)\\n\\n log_likelihood_fn = lambda out, batch: out\\n model_prior_kl_fn = lambda out, params, index: np.zeros_like(out)\\n\\n elbo_loss = ElboLoss(\\n log_likelihood_fn=log_likelihood_fn,\\n model_prior_kl_fn=model_prior_kl_fn)\\n\\n loss, unused_loss_metrics = elbo_loss(\\n apply=apply, params=params, batch=batch, index=index)\\n self.assertTrue((loss == -output).all(),\\n f'expected elbo loss to be {-output} but it is {loss}')\",\n \"def are_residuals_near_zero(pts):\\n y = regress(pts)[1]\\n return all(map(near_zero, y))\",\n \"def grad_zero(self):\\r\\n pass\",\n \"def grad_zero(self):\\r\\n pass\",\n \"def test_Sobol_G_raises_error_if_values_lt_zero():\\n evaluate(np.array([0, -1, -.02, 1, 1, -0.1, -0, -12]))\",\n \"def test_invalid_target(self):\\n y_valid = np.random.randint(2, size=100)\\n y_invalid = np.random.uniform(size=100)\\n\\n oz = ClassBalance()\\n\\n with pytest.raises(YellowbrickValueError):\\n oz.fit(y_invalid)\\n\\n with pytest.raises(YellowbrickValueError):\\n oz.fit(y_valid, y_invalid)\",\n \"def testSlopeBadLength(self):\\n def setSlope():\\n self.node.slope = ['banana']\\n\\n self.assertRaises(\\n ValueError,\\n setSlope\\n )\",\n \"def test_check_null_weight_with_nonzeros() -> None:\\n sample_weight = np.ones_like(y_toy)\\n sw_out, X_out, y_out = check_null_weight(sample_weight, X_toy, y_toy)\\n np.testing.assert_almost_equal(sw_out, sample_weight)\\n np.testing.assert_almost_equal(X_out, X_toy)\\n np.testing.assert_almost_equal(y_out, y_toy)\",\n \"def model_zero(df, offset, harmonize_year=\\\"2015\\\"):\\n # current decision is to return a simple offset, this will be a straight\\n # line for all time periods. previous behavior was to set df[numcols] = 0,\\n # i.e., report 0 if model reports 0.\\n return constant_offset(df, offset)\",\n \"def zero_one_loss(self, normalize=True):\\n zero_one_loss = len((self.y_true - self.y_pred).nonzero()[0])\\n if normalize:\\n zero_one_loss /= len(self.y_pred)\\n return zero_one_loss\",\n \"def set_zero(self, loc=None):\\n self.Y[loc] -= self.Y[loc]\",\n \"def zero_negative_weights(self):\\n for k in range(len(self)):\\n self[k] *= 0 if self[k] < 0 else 1\\n self.finalized = True\\n return self\",\n \"def testSetSlopeWithNegativeString(self):\\n def setSlope():\\n self.node.slope = '-20'\\n\\n cdl_convert.config.HALT_ON_ERROR = True\\n\\n self.assertRaises(\\n ValueError,\\n setSlope\\n )\\n\\n cdl_convert.config.HALT_ON_ERROR = False\\n\\n setSlope()\\n\\n self.assertEqual(\\n (Decimal('0.0'), Decimal('0.0'), Decimal('0.0')),\\n self.node.slope\\n )\",\n \"def elbow_with_synthetic_data():\\n delta = 0.1\\n slope_2 = 2\\n slope_3 = 3\\n break_pt = 5\\n intercept_2 = 0.0\\n line_2 = np.arange(0, break_pt, delta) * slope_2 + intercept_2\\n line_3 = (\\n np.arange(break_pt, break_pt * 2, delta) * slope_3\\n + (slope_2 - slope_3) * break_pt\\n )\\n x = np.arange(0, break_pt * 2, delta)\\n y = np.concatenate((line_2, line_3))\\n break_pt = break_pt\\n\\n return x, y, break_pt\",\n \"def __init__(self, negative_slope=0.01, inplace=False):\\n super(LeakyReLU, self).__init__()\\n self.negative_slope = negative_slope\\n self.inplace = inplace\",\n \"def grad_zero(self):\\r\\n for layer in self.layers:\\r\\n layer.grad_zero()\",\n \"def test_greaterThanZero(self):\\n\\t\\tX = []\\n\\t\\tY1 = []\\n\\t\\tY2 = []\\n\\t\\tcandidate = [0,2,3,4]\\n\\t\\tfor i in range(DATA_POINTS_NUM):\\n\\t\\t\\tX.append((i - DATA_POINTS_NUM/2)*0.1)\\n\\t\\t\\tY1.append(polynomi_3N(REFERENCE, X[-1]))\\n\\t\\t\\tY2.append(polynomi_3N(candidate, X[-1]))\\n\\t\\tret = calculate_fitness(Y1, Y2)\\n\\t\\tself.assertFalse( 0 > ret, \\n\\t\\t \\\"Something wrong with fitness calculation\\\")\\n\\t\\tprint ret\",\n \"def test__validate_nan_output(straight_line):\\n x, y0, y1, y2 = straight_line\\n # Horizontal line\\n elbow = find_elbow_point(x, y0)\\n assert np.isnan(elbow)\\n\\n # Vertical line\\n elbow = find_elbow_point(x, y2)\\n assert np.isnan(elbow)\\n\\n # A line, but no elbow.\\n elbow = find_elbow_point(x, y1)\\n assert np.isnan(elbow)\",\n \"def test_extreme_values(self):\\n with pytest.warns(RuntimeWarning) as warninfo:\\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\\n with pytest.warns(RuntimeWarning) as warninfo:\\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\",\n \"def min_zero_crossings(self):\\n return self._MIN_ZERO_CROSSINGS\",\n \"def testSlopeBadLength(self):\\n def setSlope():\\n self.cc.slope = ['banana']\\n\\n self.assertRaises(\\n ValueError,\\n setSlope\\n )\",\n \"def initializeWeightsToZero(self):\\n\\t\\t## YOUR CODE BELOW\\n\\t\\t\\n\\t\\tutil.raiseNotDefined()\\n\\t\\treturn\",\n \"def is_zero(self):\\n return -0.0001 <= self.l2_norm() <= 0.0001\",\n \"def test_Sobol_G_raises_error_if_values_lt_zero():\\n with raises(ValueError):\\n evaluate(np.array([0, -1, -.02, 1, 1, -0.1, -0, -12]))\",\n \"def slope(l):\\n if l[1] == l[0]:\\n return float(\\\"inf\\\")\\n else:\\n return float(l[3]-l[2])/(l[1]-l[0])\",\n \"def model_fixed_slope(train_x, train_y, test_x, slope=1):\\n intercept = np.mean(train_y - train_x*slope)\\n model_info = {'model': 'fixed_slope', 'const': intercept}\\n predictions = test_x*slope + intercept\\n return predictions, model_info\",\n \"def test__validate_with_synthetic_data_plus_noise(elbow_with_synthetic_data):\\n # Test with an odd number of points\\n x, y, break_pt = elbow_with_synthetic_data\\n np.random.seed(12)\\n range = (y.max() - y.min()) * 0.02\\n y = y + np.random.randn(y.shape[0]) * range\\n expected_elbow = np.argmin(np.abs(x - break_pt))\\n found_elbow = find_elbow_point(x, y)\\n assert abs(found_elbow - expected_elbow) < 10\\n\\n # Test with an even number of points\\n x, y, break_pt = elbow_with_synthetic_data\\n range = (y.max() - y.min()) * 0.02\\n y = y + np.random.randn(y.shape[0]) * range\\n expected_elbow = np.argmin(np.abs(x - break_pt))\\n found_elbow = find_elbow_point(x, y, max_iter=40)\\n assert abs(found_elbow - expected_elbow) < 10\",\n \"def test_linear_binomial_fails_leading_zero(self):\\n self.assertRaises(ValueError, LinearBinomial, 0, 1)\",\n \"def baseline_deviation_1_rule(_m, y):\\r\\n\\r\\n if y == m.Y.first():\\r\\n return Constraint.Skip\\r\\n else:\\r\\n return m.z_b1[y] >= m.baseline[y] - m.baseline[y - 1]\",\n \"def _no_reg(self, y, x, y_minus_g, w_0):\\n # Initialize weight vector to return\\n w_1 = np.zeros(len(w_0))\\n \\n ascent = self._epsilon * y_minus_g\\n \\n for j in range(len(x)):\\n w_1[j] = w_0[j] + x[j]*ascent\\n \\n return w_1\",\n \"def testSlopeDefault(self):\\n self.assertEqual(\\n (Decimal('1.0'), Decimal('1.0'), Decimal('1.0')),\\n self.node.slope\\n )\",\n \"def handle_slopes(self, slopeG):\\n\\n\\n\\n colSprite = pygame.sprite.spritecollideany(self, slopeG)\\n if colSprite: #and self.rect.y < colSprite.rect.y:\\n self.fall = False\\n\\n tl = colSprite.rect.topleft # used for slope calculation only\\n br = colSprite.rect.bottomright\\n\\n m1 = float((br[1]-tl[1])/(br[0]-tl[0])) # y2-y1/(x2-x1)\\n angle_rad = math.atan(m1) # from atan(m1 - m1 /(1+m1m2))\\n # The angle is normally 45 degrees\\n\\n if self.x_vel:\\n #le = self.x_vel / abs(self.x_vel) * 4\\n le = self.x_vel\\n else:\\n le = 0\\n\\n x_move_len = le\\n y_move_len = self.calc_vertical(x_move_len, angle_rad)\\n\\n # just for debugging\\n self.d1 = x_move_len\\n self.d2 = y_move_len\\n\\n # Now, it is needed to move the player down till\\n # he reaches the 'essence' of the slope. This is because I\\n # am too lazy to implement pixel-perfect collision.\\n # Since this is to be done only once, a variable will be used\\n # to keep track of whether this has beend donef for one slope or not\\n\\n # tolerance for height changing\\n tol = False\\n if abs(colSprite.rect.topleft[1] - self.rect.bottomleft[1]) <= 10:\\n tol = True\\n #print \\\"ABS \\\", abs(colSprite.rect.topleft[1] - self.rect.bottomleft[1])\\n\\n if not self.prev_slope and tol:\\n self.prev_slope = True\\n\\n x_off_mov = colSprite.rect.topleft[0] - self.rect.bottomleft[0]\\n y_off_mov = self.calc_vertical(x_off_mov, angle_rad)\\n\\n # handling for rightwards velocity\\n if self.direction == RIGHT:\\n y_off_mov = -y_off_mov\\n\\n\\n self.rect.move_ip((0, y_off_mov))\\n\\n # check collision with any slope\\n\\n #self.rect.move_ip((x_move_len, y_move_len))\\n # it seems that the above code is redundant; will check\\n self.rect.move_ip((-self.x_vel, 0)) # undo the shifting\\n self.rect.move_ip((x_move_len, y_move_len))\\n\\n else:\\n self.prev_slope = False\",\n \"def calculate_y(y0,ey,ymax,PBC=True):\\r\\n\\ty = y0 + dt*np.cumsum(ey)\\r\\n\\twhile (y>ymax).any() or (y<0.0).any():\\r\\n\\t\\tidg = (y>ymax)\\r\\n\\t\\ty[idg] = 2*ymax - y[idg] if PBC else ymax\\r\\n\\t\\tidl = (y<0.0)\\r\\n\\t\\ty[idl] *= -1.0\\r\\n\\treturn y\",\n \"def test_is_valid_fujita_rating_ef_leading_zero(self):\\n\\n self.assertTrue(\\n tornado_io._is_valid_fujita_rating(EF_SCALE_RATING_LEADING_ZERO)\\n )\",\n \"def test_nans_in_x_data(self):\\n alpha = 0.9\\n num_x = 150\\n num_y = 100\\n x_vals = np.linspace(0, 2 * np.pi, num_x)\\n x_vals[45] = np.nan\\n y_vals = (np.sin(x_vals[:num_y]) + 0.3 * np.random.randn(num_y) + 0.5)\\n\\n with pytest.raises(RuntimeError):\\n extrapolated_lowess(x_vals, y_vals, alpha=alpha)\",\n \"def smooth_negative_labels(y):\\n return y + (np.random.random(y.shape) * 0.1)\",\n \"def test_zero(self):\\n controller = LinearController(self.G, 2, mode='zero')\\n sim = simulation.Simulation(self.G, controller, dt=self.dt)\\n sim.run(self.dt)\\n\\n self.assertAlmostEqual(np.linalg.norm(controller.W.ravel()), 0.0)\\n self.assertAlmostEqual(np.linalg.norm(controller.out), 0.0)\",\n \"def zero_crossings(x):\\n return np.array(np.where(np.diff(np.sign(x)))[0])\",\n \"def __init__(self):\\n self.slope = -1.0\\n self.last_obs = -1.0\\n self.last_obs_ind = -1\\n self._fitted = False\",\n \"def _correct_coefs(coefs):\\n coefs = coefs.copy().flatten()\\n coefs[coefs < 0] = 0\\n coefs /= coefs.sum() # Normalize to sum to 1\\n return coefs\",\n \"def absolute_trick(bias, slope, predictor, current_value, learning_rate):\\n predicted_value = bias + slope*predictor\\n if current_value > predicted_value:\\n slope += learning_rate*predictor\\n bias += learning_rate\\n else:\\n slope -= learning_rate*predictor\\n bias -= learning_rate\\n return slope, bias\",\n \"def test_find_append_zero_crossings():\\n x = np.arange(11) * units.hPa\\n y = np.array([3, 2, 1, -1, 2, 2, 0, 1, 0, -1, 2]) * units.degC\\n x2, y2 = _find_append_zero_crossings(x, y)\\n\\n x_truth = np.array([0., 1., 2., 2.4494897, 3., 3.3019272, 4., 5.,\\n 6., 7., 8., 9., 9.3216975, 10.]) * units.hPa\\n y_truth = np.array([3, 2, 1, 0, -1, 0, 2, 2, 0, 1, 0, -1, 0, 2]) * units.degC\\n assert_array_almost_equal(x2, x_truth, 6)\\n assert_almost_equal(y2, y_truth, 6)\",\n \"def _test5():\\n# import matplotlib.pyplot as plt\\n from math import pi, cos, sin\\n n = 800\\n PI2 = 2.0*pi\\n angle = PI2 / n\\n pts = []\\n r = 10.0\\n for i in range(n):\\n beta = i * angle\\n x = r*cos(beta)\\n y = r*sin(beta)\\n pts.append((x, y))\\n print (regress(pts))\\n are_zero = are_residuals_near_zero(pts)\",\n \"def fixed_baseline(random_seeds, train_data, test_data):\\n\\n err = 0.\\n\\n for seed in random_seeds:\\n np.random.seed(seed)\\n\\n data = prep_data(train_data, test_data)\\n\\n wrong = 0.\\n for i in range(data['test_rows']):\\n if not data['test_ys'][i] == 1.0:\\n wrong += 1\\n\\n err += wrong / data['test_rows']\\n\\n return err / len(random_seeds)\",\n \"def test_init_vals_length_error_in_fit_mle(self):\\n # Note there is only one beta, so we can't go lower than zero betas.\\n original_intercept_ref_position = self.fake_intercept_ref_pos\\n for intercept_ref_position in [None, original_intercept_ref_position]:\\n self.base_clog.intercept_ref_position = intercept_ref_position\\n for i in [1, -1]:\\n # This will ensure we have too many or too few intercepts\\n num_coefs = self.fake_betas.shape[0] + i\\n\\n # Test to ensure that the ValueError when using an\\n # init_intercepts kwarg with an incorrect number of parameters\\n self.assertRaisesRegexp(ValueError,\\n \\\"dimension\\\",\\n self.base_clog.fit_mle,\\n np.arange(num_coefs),\\n print_res=False)\\n\\n return None\",\n \"def model_fun(params, slope, x):\\n w = params['w']\\n t0 = params['t0']\\n offset = params['offset']\\n return offset + slope * jax.nn.sigmoid(jnp.dot(x, w) - t0)\",\n \"def test_zero_degree_polynomial(cls):\\n\\n MESSAGE = \\\"Degree of polynomial must be positive or null\\\"\\n\\n if cls.n_inputs == 1: # Test 1D polynomials\\n p1 = cls(degree=0, c0=1)\\n assert p1(0) == 1\\n assert np.all(p1(np.zeros(5)) == np.ones(5))\\n\\n x = np.linspace(0, 1, 100)\\n # Add a little noise along a straight line\\n y = 1 + np.random.uniform(0, 0.1, len(x))\\n\\n p1_init = cls(degree=0)\\n fitter = fitting.LinearLSQFitter()\\n p1_fit = fitter(p1_init, x, y)\\n\\n # The fit won't be exact of course, but it should get close to within\\n # 1%\\n assert_allclose(p1_fit.c0, 1, atol=0.10)\\n\\n # Error from negative degree\\n with pytest.raises(ValueError, match=MESSAGE):\\n cls(degree=-1)\\n elif cls.n_inputs == 2: # Test 2D polynomials\\n if issubclass(cls, OrthoPolynomialBase):\\n p2 = cls(x_degree=0, y_degree=0, c0_0=1)\\n\\n # different shaped x and y inputs\\n a = np.array([1, 2, 3])\\n b = np.array([1, 2])\\n with mk.patch.object(\\n PolynomialBase,\\n \\\"prepare_inputs\\\",\\n autospec=True,\\n return_value=((a, b), mk.MagicMock()),\\n ):\\n with pytest.raises(\\n ValueError, match=r\\\"Expected input arrays to have the same shape\\\"\\n ):\\n p2.prepare_inputs(mk.MagicMock(), mk.MagicMock())\\n\\n # Error from negative degree\\n with pytest.raises(ValueError, match=MESSAGE):\\n cls(x_degree=-1, y_degree=0)\\n with pytest.raises(ValueError, match=MESSAGE):\\n cls(x_degree=0, y_degree=-1)\\n else:\\n p2 = cls(degree=0, c0_0=1)\\n\\n # Error from negative degree\\n with pytest.raises(ValueError, match=MESSAGE):\\n cls(degree=-1)\\n\\n assert p2(0, 0) == 1\\n assert np.all(p2(np.zeros(5), np.zeros(5)) == np.ones(5))\\n\\n y, x = np.mgrid[0:1:100j, 0:1:100j]\\n z = (1 + np.random.uniform(0, 0.1, x.size)).reshape(100, 100)\\n\\n if issubclass(cls, OrthoPolynomialBase):\\n p2_init = cls(x_degree=0, y_degree=0)\\n else:\\n p2_init = cls(degree=0)\\n fitter = fitting.LinearLSQFitter()\\n p2_fit = fitter(p2_init, x, y, z)\\n\\n assert_allclose(p2_fit.c0_0, 1, atol=0.10)\",\n \"def y_axis_left_zero(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"y_axis_left_zero\\\")\",\n \"def init_standard_poly(basetensor, ind, x):\\n ind.zeroAllBut(0, 0)\\n basetensor[ind.all+ind.getCurrent()] = 1.\\n for i in range(x.shape[1]):\\n ind.zeroAllBut(i, 1)\\n basetensor[ind.all + ind.getCurrent()] = x[:, i]\",\n \"def aerosols(self):\\n return 1.\",\n \"def calc_error(self):\\n if self._fit_data.y is not None and self._fit_data.y_fit is not None:\\n self._fit_data.error_vector = self._fit_data.y - self._fit_data.y_fit\",\n \"def zero_calibrationn(self):\\n self.link.write(self._calibrateZeroSequence)\",\n \"def zero_crossings(y_axis, window = 11):\\n # smooth the curve\\n length = len(y_axis)\\n x_axis = np.asarray(range(length), int)\\n \\n # discard tail of smoothed signal\\n y_axis = _smooth(y_axis, window)[:length]\\n zero_crossings = np.where(np.diff(np.sign(y_axis)))[0]\\n indices = [x_axis[index] for index in zero_crossings]\\n \\n # check if zero-crossings are valid\\n diff = np.diff(indices)\\n if diff.std() / diff.mean() > 0.2:\\n print diff.std() / diff.mean()\\n print np.diff(indices)\\n raise(ValueError, \\n \\\"False zero-crossings found, indicates problem {0} or {1}\\\".format(\\n \\\"with smoothing window\\\", \\\"problem with offset\\\"))\\n # check if any zero crossings were found\\n if len(zero_crossings) < 1:\\n raise(ValueError, \\\"No zero crossings found\\\")\\n \\n return indices \\n # used this to test the fft function's sensitivity to spectral leakage\\n #return indices + np.asarray(30 * np.random.randn(len(indices)), int)\\n # Calculate X profile for page split\",\n \"def accuracy_on_zero(y_true, y_pred):\\n \\n y_true_flipped = 1 - y_true\\n y_pred_flipped = 1- y_pred\\n \\n sum_true_negatives = K.sum(K.round(K.clip( y_true_flipped * y_pred_flipped, 0, 1)))\\n \\n sum_all_negatives = K.sum(K.round(K.clip(y_true_flipped, 0, 1)))\\n \\n acc_on_zero = sum_true_negatives / (sum_all_negatives + K.epsilon())\\n return acc_on_zero\",\n \"def leoGiddingsFit(self,zeroX_to_LEO_limit,calib_zeroX_to_peak,calib_gauss_width):\\r\\n\\r\\n\\t\\t#run the scatteringPeakInfo method to retrieve various peak attributes \\r\\n\\t\\tself.scatteringPeakInfo()\\r\\n\\t\\t\\r\\n\\t\\t#get the baseline\\r\\n\\t\\tbaseline = self.scatteringBaseline\\r\\n\\t\\t\\r\\n\\t\\t#get the zero-crossing for the particle\\r\\n\\t\\tzero_crossing_pt_LEO = self.zeroCrossing(evap_threshold)\\r\\n\\t\\t\\r\\n\\t\\tif zero_crossing_pt_LEO < 0: #ie we can't find the zero crossing\\r\\n\\t\\t\\tself.LF_scattering_amp = -2\\r\\n\\t\\t\\tself.LF_baseline = -2\\r\\n\\t\\t\\tself.LF_results = []\\r\\n\\t\\t\\tself.LF_max_index = -2\\r\\n\\t\\t\\tself.beam_center_pos = -2\\r\\n\\t\\t\\t\\r\\n\\t\\telse:\\r\\n\\t\\t\\t#LEO max index sets the x-limit for fitting based on the desired magnification factor\\r\\n\\t\\t\\tLEO_max_index = int(round(zero_crossing_pt_LEO-zeroX_to_LEO_limit))\\r\\n\\t\\t\\r\\n\\t\\t\\tself.LF_max_index = LEO_max_index\\r\\n\\t\\t\\tLEO_min_index = 0\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tx_vals_all = np.array(self.getAcqPoints()) + 1 #avoids divide by zero in Giddings fit\\r\\n\\t\\t\\tself.LF_x_vals_to_use = x_vals_all[LEO_min_index:LEO_max_index]\\r\\n\\r\\n\\t\\t\\ty_vals_all = np.array(self.getScatteringSignal())\\r\\n\\t\\t\\tself.LF_y_vals_to_use = y_vals_all[LEO_min_index:LEO_max_index]\\r\\n\\r\\n\\t\\t\\tself.beam_center_pos = zero_crossing_pt_LEO-calib_zeroX_to_peak\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\tdef LEOGiddings(x, a):\\r\\n\\t\\t\\t\\t# Note: scipy.special.iv is the modified Bessel function of the first kind\\r\\n\\t\\t\\t\\treturn baseline + (a/calib_gauss_width)*np.sqrt(self.beam_center_pos/x)*(scipy.special.iv(0,(2*np.sqrt(self.beam_center_pos*x)/calib_gauss_width))) * np.exp((-x-self.beam_center_pos)/calib_gauss_width)\\r\\n\\r\\n\\t\\t\\t#run the fitting\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tpopt, pcov = curve_fit(LEOGiddings, self.LF_x_vals_to_use, self.LF_y_vals_to_use)\\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tpopt, pcov = [-1], [np.nan] \\r\\n\\t\\r\\n\\r\\n\\t\\t\\tfit_result = []\\r\\n\\t\\t\\tfor x in x_vals_all:\\r\\n\\t\\t\\t\\tfit_result.append(LEOGiddings(x,popt[0]))\\r\\n\\t\\t\\tself.LF_results = fit_result\\r\\n\\t\\t\\tself.LF_scattering_amp = np.max(fit_result)-baseline#popt[0] \\r\\n\\t\\t\\tself.LF_baseline = np.nan\",\n \"def hinge(datax,datay,w):\\n #hinge: si bien classifie, -y<0 sinon >0. On ne compte celui sont mal-classifies\\n fx = np.dot(datax, w.T)\\n return np.mean(np.where(-datay*fx<0,0,-datay*fx))\",\n \"def fun(params, slope, data):\\n x, y_true = data\\n return y_true - model_fun(params, slope, x)\",\n \"def zero_crosser(indicator: pd.Series) -> pd.Series:\\n indicator = indicator.fillna(0)\\n return (((indicator.shift() * indicator) <= 0) * np.sign(indicator)).astype(int)\",\n \"def testAlphaZeroNllsMatchACauchyDistribution(self):\\n x = jnp.linspace(-10, 10, 1000)\\n scale = 1.7\\n nll = self.variant(self._distribution.nllfun)(x, 0, scale)\\n nll_true = -scipy.stats.cauchy(0, scale * jnp.sqrt(2)).logpdf(x)\\n chex.assert_tree_all_close(nll, nll_true, atol=1e-5, rtol=1e-5)\",\n \"def zzX_zero_of(f, d=0):\\n return zzX_zero(poly_level(f)-d)\",\n \"def update_weights_negative(self):\\n eta = self.config.eta\\n self.w_xh -= eta * (self.x.T @ self.h)\\n self.w_th -= eta * (self.t.T @ self.h)\\n self.w_ho -= eta * (self.h.T @ self.o) \\n self.w_hz -= eta * (self.h.T @ self.z)\",\n \"def test_y0_provided(self):\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=2)\\r\\n\\r\\n with qml.tape.JacobianTape() as tape:\\r\\n qml.RX(0.543, wires=[0])\\r\\n qml.RY(-0.654, wires=[0])\\r\\n qml.expval(qml.PauliZ(0))\\r\\n\\r\\n f0 = dev.execute(tape)\\r\\n tapes, fn = finite_diff(tape, approx_order=1, f0=f0)\\r\\n\\r\\n # one tape per parameter, plus one global call\\r\\n assert len(tapes) == tape.num_params\",\n \"def linear_slope_fit(wf, mean_y, sigma_y, slope, intercept):\\n\\n sum_x = sum_x2 = sum_xy = sum_y = mean_y[0] = sigma_y[0] = 0\\n isum = len(wf)\\n\\n for i,value in enumerate(wf):\\n sum_x += i \\n sum_x2 += i**2\\n sum_xy += (value * i)\\n sum_y += value\\n mean_y += (value-mean_y) / (i+1)\\n sigma_y += (value-mean_y)**2\\n\\n\\n sigma_y /= (isum + 1)\\n np.sqrt(sigma_y, sigma_y)\\n\\n\\n slope[0] = (isum * sum_xy - sum_x * sum_y) / (isum * sum_x2 - sum_x * sum_x)\\n intercept[0] = (sum_y - sum_x * slope[0])/isum\",\n \"def e0_xy_correction(map : ASectorMap ,\\n norm_strat : norm_strategy = norm_strategy.max):\\n normalization = get_normalization_factor(map , norm_strat)\\n get_xy_corr_fun = maps_coefficient_getter (map.mapinfo, map.e0)\\n def geo_correction_factor(x : np.array,\\n y : np.array) -> np.array:\\n return correct_geometry_(get_xy_corr_fun(x,y))* normalization\\n return geo_correction_factor\",\n \"def y0(self):\\n return self._y0\",\n \"def y0(self):\\n return self.params['y0']\",\n \"def test_wrong_gradients_raises_assertion(self):\\n model = PoincareModel(self.data, negative=3)\\n model._loss_grad = Mock(return_value=np.zeros((2 + model.negative, model.size)))\\n with self.assertRaises(AssertionError):\\n model.train(epochs=1, batch_size=1, check_gradients_every=1)\",\n \"def __init__(self, neg_slope):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n\\n\\n self.neg_slope = neg_slope\\n\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def test_init_intercepts_length_error_in_fit_mle(self):\\n # Create a variable for the arguments to the fit_mle function.\\n # Note `None` is the argument passed when using the init_intercepts\\n # and init_coefs keyword arguments.\\n fit_args = [None]\\n\\n # Create base set of kwargs for fit_mle function\\n kwargs = {\\\"init_coefs\\\": self.fake_betas,\\n \\\"print_res\\\": False}\\n\\n for i in [1, -1]:\\n # This will ensure we have too many or too few intercepts\\n num_intercepts = self.fake_intercepts.shape[0] + i\\n kwargs[\\\"init_intercepts\\\"] = np.arange(num_intercepts)\\n\\n # Test to ensure that the ValueError is raised when using an\\n # init_intercepts kwarg with an incorrect number of parameters\\n self.assertRaises(ValueError, self.base_clog.fit_mle,\\n *fit_args, **kwargs)\\n\\n return None\",\n \"def test_zero_bootstrapping(self, num_classes: int):\\n\\n loss_fn = single_index.XentLoss(num_classes)\\n batch_size = 4\\n batch = base.Batch(\\n x=np.expand_dims(np.arange(batch_size), 1),\\n y=np.random.random_integers(0, num_classes - 1, size=(batch_size, 1)),\\n data_index=np.expand_dims(np.arange(batch_size), 1),\\n weights=np.zeros([batch_size, 1]),\\n )\\n\\n # Test when apply always return a uniform distribution over labels\\n apply = lambda p, x, i: np.ones(shape=(x.shape[0], num_classes))\\n loss, unused_metrics = loss_fn(\\n apply=apply, params=self._params, batch=batch, index=self._index)\\n self.assertEqual(\\n loss, 0.0, ('expected loss with zero bootstrapping weights to be zero, '\\n f'but it is {loss}'))\",\n \"def fit_slope_1d(X,Y):\\n Sx = np.sum(X)\\n Sy = np.sum(Y)\\n Sxx = np.sum(np.power(X,2))\\n Sxy = np.sum(X*Y)\\n Syy = np.sum(np.power(Y,2)) \\n n = len(X)*1.\\n slope = (n*Sxy - Sx*Sy)/(n*Sxx-Sx**2)\\n alpha = Sy/n - slope*Sx/n\\n return slope, alpha\",\n \"def calculate_zero_cross_rate(series):\\n series_mean = np.mean(series)\\n series = [v - series_mean for v in series]\\n zero_cross_count = (np.diff(np.sign(series)) != 0).sum()\\n return zero_cross_count / len(series)\",\n \"def test__repeated_median_catch_division_by_zero(repeated_median):\\n *_, divzero_x, divzero_y = repeated_median\\n assert repeated_median_slope(divzero_x, divzero_y) == 1.0\",\n \"def __init__(self, neg_slope):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n self.neg_slope = neg_slope\\n self.input_cache = None\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def NoisySlope(x,y, dx, plot=None):\\n # compute slopes\\n slopes = []\\n synth = np.zeros(len(x))\\n x0 = x[0]\\n xmax = x.max()\\n\\n # default slope\\n def_slope = (y[-1]-y[0])/(x[-1]-x[0])\\n while x0+dx=x0)*(x<=x0+dx))\\n if len(w[0])>10:\\n coef = np.polyfit(x[w]-x[w].mean(), y[w], 1)\\n slopes.append(coef[0])\\n synth[w] = np.polyval(coef, x[w]-x[w].mean())\\n else:\\n if len(w[0])>0:\\n synth[w] = y[w][0]+def_slope*(x[w]-x[w][0])\\n x0 += dx\\n\\n # sigma clipping\\n slopes = np.array(slopes)\\n t = np.linspace(slopes.min(), slopes.max(), 500)\\n s = slopes.argsort()\\n slopes = slopes[s]\\n r = slopes[int(len(slopes)*.7)]-slopes[int(len(slopes)*.3)]\\n w = np.where((slopes>=(np.median(slopes)-2*r))*\\\\\\n (slopes<=(np.median(slopes)+2*r)))\\n guess = [0.0, 0.0, np.median(slopes), r]\\n best = myfit.fit(myfit.erf, slopes[w], guess, \\\\\\n np.linspace(0,1,len(slopes))[w])\\n best = best.leastsqfit()\\n\\n plt.figure(20)\\n plt.clf()\\n plt.plot(slopes*1e6, np.linspace(0,1,len(slopes)), 'ob')\\n plt.plot(slopes[w]*1e6, np.linspace(0,1,len(slopes))[w], 'or')\\n plt.plot(t*1e6, myfit.erf(t,best), 'r', linewidth=2)\\n plt.xlim((best[2]-5*best[3])*1e6,\\\\\\n (best[2]+5*best[3])*1e6)\\n plt.xlabel('slope (um/s)')\\n\\n return (best[2],best[3], synth)\",\n \"def zero_norm(arr):\\n arr = 2 * (arr - min(arr)) / (max(arr) - min(arr)) - 1\\n return arr - np.sum(arr) / len(arr)\",\n \"def test_PredictionEnsemble_smooth_None(\\r\\n perfectModelEnsemble_initialized_control_1d_ym_cftime,\\r\\n):\\r\\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\\r\\n pm_smoothed = pm.smooth(None)\\r\\n assert_PredictionEnsemble(pm, pm_smoothed)\",\n \"def formula_0(x: np.ndarray) -> np.ndarray:\\n logx = np.log(x)\\n denom = x - 1\\n k0 = (x - logx * x - 1) / denom\\n return k0\"\n]"},"negative_scores":{"kind":"list like","value":["0.61061126","0.5953062","0.5737827","0.5657327","0.56395733","0.56212384","0.5598636","0.558573","0.55028105","0.5377003","0.53153276","0.5299184","0.52155274","0.52150947","0.5214609","0.5210322","0.52011937","0.5195882","0.51850694","0.5184016","0.5161594","0.5149885","0.51342463","0.5130136","0.51177347","0.5021125","0.5021125","0.50197446","0.50143087","0.50131196","0.4991711","0.49904516","0.4983365","0.49773583","0.49698606","0.49690804","0.49657696","0.4946001","0.49392942","0.49315557","0.49232957","0.49210867","0.49179593","0.49164388","0.48947844","0.4886675","0.48836887","0.48832315","0.48785064","0.48680747","0.4863717","0.48566017","0.48536232","0.4848468","0.4835618","0.4827457","0.48210138","0.48161885","0.4801223","0.48008335","0.47959286","0.47924757","0.47910172","0.47875008","0.47750688","0.477314","0.4772114","0.47711724","0.47660536","0.47597596","0.47590104","0.47520363","0.4734945","0.4734138","0.47290692","0.47259548","0.47234258","0.47171393","0.47118706","0.47078735","0.47068343","0.47065902","0.4704764","0.46891892","0.4687773","0.46853852","0.46829256","0.46804616","0.4675477","0.46743616","0.46661332","0.4665546","0.4658609","0.46541867","0.46533725","0.465131","0.4649526","0.46484128","0.46470562","0.46465614","0.46453163"],"string":"[\n \"0.61061126\",\n \"0.5953062\",\n \"0.5737827\",\n \"0.5657327\",\n \"0.56395733\",\n \"0.56212384\",\n \"0.5598636\",\n \"0.558573\",\n \"0.55028105\",\n \"0.5377003\",\n \"0.53153276\",\n \"0.5299184\",\n \"0.52155274\",\n \"0.52150947\",\n \"0.5214609\",\n \"0.5210322\",\n \"0.52011937\",\n \"0.5195882\",\n \"0.51850694\",\n \"0.5184016\",\n \"0.5161594\",\n \"0.5149885\",\n \"0.51342463\",\n \"0.5130136\",\n \"0.51177347\",\n \"0.5021125\",\n \"0.5021125\",\n \"0.50197446\",\n \"0.50143087\",\n \"0.50131196\",\n \"0.4991711\",\n \"0.49904516\",\n \"0.4983365\",\n \"0.49773583\",\n \"0.49698606\",\n \"0.49690804\",\n \"0.49657696\",\n \"0.4946001\",\n \"0.49392942\",\n \"0.49315557\",\n \"0.49232957\",\n \"0.49210867\",\n \"0.49179593\",\n \"0.49164388\",\n \"0.48947844\",\n \"0.4886675\",\n \"0.48836887\",\n \"0.48832315\",\n \"0.48785064\",\n \"0.48680747\",\n \"0.4863717\",\n \"0.48566017\",\n \"0.48536232\",\n \"0.4848468\",\n \"0.4835618\",\n \"0.4827457\",\n \"0.48210138\",\n \"0.48161885\",\n \"0.4801223\",\n \"0.48008335\",\n \"0.47959286\",\n \"0.47924757\",\n \"0.47910172\",\n \"0.47875008\",\n \"0.47750688\",\n \"0.477314\",\n \"0.4772114\",\n \"0.47711724\",\n \"0.47660536\",\n \"0.47597596\",\n \"0.47590104\",\n \"0.47520363\",\n \"0.4734945\",\n \"0.4734138\",\n \"0.47290692\",\n \"0.47259548\",\n \"0.47234258\",\n \"0.47171393\",\n \"0.47118706\",\n \"0.47078735\",\n \"0.47068343\",\n \"0.47065902\",\n \"0.4704764\",\n \"0.46891892\",\n \"0.4687773\",\n \"0.46853852\",\n \"0.46829256\",\n \"0.46804616\",\n \"0.4675477\",\n \"0.46743616\",\n \"0.46661332\",\n \"0.4665546\",\n \"0.4658609\",\n \"0.46541867\",\n \"0.46533725\",\n \"0.465131\",\n \"0.4649526\",\n \"0.46484128\",\n \"0.46470562\",\n \"0.46465614\",\n \"0.46453163\"\n]"},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":1694,"cells":{"query":{"kind":"string","value":"Instance data use_wsdl if True try to construct XML Instance from information in WSDL."},"document":{"kind":"string","value":"def __init__(self, wsdl, service=None, port=None, tracefile=None,\r\n typesmodule=None, nsdict=None, soapAction=None, ns=None, op_ns=None, use_wsdl=False):\r\n if not hasattr(wsdl, 'targetNamespace'):\r\n wsdl = wstools.WSDLTools.WSDLReader().loadFromURL(wsdl)\r\n\r\n# for item in wsdl.types.items():\r\n# self._serializer.loadSchema(item)\r\n\r\n self._service = wsdl.services[service or 0]\r\n self.__doc__ = self._service.documentation\r\n self._port = self._service.ports[port or 0]\r\n self._name = self._service.name\r\n self._wsdl = wsdl\r\n self._tracefile = tracefile\r\n self._typesmodule = typesmodule\r\n self._nsdict = nsdict or {}\r\n self._soapAction = soapAction\r\n self._ns = ns\r\n self._op_ns = op_ns\r\n self._use_wsdl = use_wsdl\r\n \r\n binding = self._port.getBinding()\r\n portType = binding.getPortType()\r\n for item in portType.operations:\r\n callinfo = wstools.WSDLTools.callInfoFromWSDL(self._port, item.name)\r\n method = MethodProxy(self, callinfo)\r\n setattr(self, item.name, method)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _prepare_wsdl_objects(self):\r\n # This holds some optional options for the request..\r\n self.AddressValidationOptions = self.client.factory.create('AddressValidationOptions')\r\n \r\n # This is good to review if you'd like to see what the data structure\r\n # looks like.\r\n self.logger.debug(self.AddressValidationOptions)","def create_wsdl_object_of_type(self, type_name):\r\n return self.client.factory.create(type_name)","def __prepare_wsdl_objects(self):\r\n pass","def get_instance(self, instance_type, name, subdir=\"\"):\r\n\r\n def read_data(data_syntax, file_name, sub_dir=\"\"):\r\n alns_data = pickle.load(open(join(self.base_path, data_syntax, \"data\", sub_dir, file_name), 'rb'))\r\n return alns_data\r\n\r\n if instance_type == \"simple\":\r\n nr_vehicles = 2\r\n nr_nodes = 4\r\n nr_customers = 3\r\n load_bucket_size = 10\r\n demand = [110, 100, 150]\r\n service_times = [10, 10, 10]\r\n start_window = [0, 0, 0]\r\n end_window = [100, 100, 100]\r\n\r\n distance_matrix = [[0, 3, 2, 3], [3, 0, 1.75, 4], [2, 1.75, 0, 2.5], [3, 4, 2.5, 0]]\r\n elevation_matrix = [[0.1, 0.2, 0, 0], [0, 0, 0.3, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\r\n\r\n return ALNSData(nr_veh=nr_vehicles,\r\n nr_nodes=nr_nodes,\r\n nr_customers=nr_customers,\r\n demand=demand,\r\n service_times=service_times,\r\n start_window=start_window,\r\n end_window=end_window,\r\n elevation_m=elevation_matrix,\r\n distance_m=distance_matrix,\r\n load_bucket_size=load_bucket_size)\r\n\r\n try:\r\n return read_data(self.code_lookup[instance_type], file_name=name, sub_dir=subdir)\r\n except KeyError:\r\n raise ValueError(\"instance_type is not known: Valid inputs are: pirmin, solomon, cordeau, homberger\")","def __init__(__self__, *,\n wsdl_endpoint_name: Optional[pulumi.Input[str]] = None,\n wsdl_service_name: Optional[pulumi.Input[str]] = None):\n if wsdl_endpoint_name is not None:\n pulumi.set(__self__, \"wsdl_endpoint_name\", wsdl_endpoint_name)\n if wsdl_service_name is not None:\n pulumi.set(__self__, \"wsdl_service_name\", wsdl_service_name)","def get_instance_from_words(data):\n inst = Dataset.get_instance_template()\n inst[\"words\"] = data\n return inst","def __init__(self, py_dict=None):\n super(RuntimeNicInfoSchema, self).__init__()\n self.set_data_type('xml')\n self.index = None\n self.label = None\n self.network = NetworkSchema()\n\n if py_dict is not None:\n self.get_object_from_py_dict(py_dict)","def convertInstanceData(self, builder, typeName, data):\n\t\tif typeName not in self.instanceDataTypeMap:\n\t\t\traise Exception('Instance data type \"' + typeName + '\" hasn\\'t been registered.')\n\n\t\tconvertedData = self.instanceDataTypeMap[typeName](self, data)\n\n\t\ttypeNameOffset = builder.CreateString(typeName)\n\t\tdataOffset = builder.CreateByteVector(convertedData)\n\n\t\tObjectData.Start(builder)\n\t\tObjectData.AddType(builder, typeNameOffset)\n\t\tObjectData.AddData(builder, dataOffset)\n\t\treturn ObjectData.End(builder)","def _prepare_wsdl_objects(self):\r\n self.DeletionControlType = self.client.factory.create('DeletionControlType')\r\n self.TrackingId = self.client.factory.create('TrackingId')\r\n self.TrackingId.TrackingIdType = self.client.factory.create('TrackingIdType')","def __init__(self, py_dict=None):\n super(ServiceManagerSchema, self).__init__()\n self.set_data_type('xml')\n self.name = None\n self.description = None\n self.revision = None\n self.objectTypeName = None\n self.vendorName = None\n self.vendorId = None\n self.thumbprint = None\n self.login = None\n self.password = None\n self.verifyPassword = None\n self.url = None\n self.restUrl = None\n self.status = None\n\n if py_dict is not None:\n self.get_object_from_py_dict(py_dict)","def test_create_instance(self):\n engine = Engine(self.config_file, self.api_token)\n\n assert isinstance(engine, Engine) is True\n assert isinstance(engine.backend, Backend) is True\n assert isinstance(engine.backend, BossBackend) is True\n assert isinstance(engine.validator, Validator) is True\n assert isinstance(engine.validator, BossValidatorV02) is True\n assert isinstance(engine.config, Configuration) is True\n\n # Schema loaded\n assert isinstance(engine.config.schema, dict) is True\n assert engine.config.schema[\"type\"] == \"object\"","def __init__(self, config_obj, wsdl_name, *args, **kwargs):\r\n self.logger = logging.getLogger('fedex')\r\n \"\"\"@ivar: Python logger instance with name 'fedex'.\"\"\"\r\n self.config_obj = config_obj\r\n \"\"\"@ivar: The FedexConfig object to pull auth info from.\"\"\"\r\n\r\n # If the config object is set to use the test server, point\r\n # suds at the test server WSDL directory.\r\n if config_obj.use_test_server:\r\n self.logger.info(\"Using test server.\")\r\n self.wsdl_path = os.path.join(config_obj.wsdl_path,\r\n 'test_server_wsdl', wsdl_name)\r\n else:\r\n self.logger.info(\"Using production server.\")\r\n self.wsdl_path = os.path.join(config_obj.wsdl_path, wsdl_name)\r\n\r\n self.client = Client('file:///%s' % self.wsdl_path.lstrip('/'))\r\n\r\n #print self.client\r\n\r\n self.VersionId = None\r\n \"\"\"@ivar: Holds details on the version numbers of the WSDL.\"\"\"\r\n self.WebAuthenticationDetail = None\r\n \"\"\"@ivar: WSDL object that holds authentication info.\"\"\"\r\n self.ClientDetail = None\r\n \"\"\"@ivar: WSDL object that holds client account details.\"\"\"\r\n self.response = None\r\n \"\"\"@ivar: The response from Fedex. You will want to pick what you\r\n want out here here. This object does have a __str__() method,\r\n you'll want to print or log it to see what possible values\r\n you can pull.\"\"\"\r\n self.TransactionDetail = None\r\n \"\"\"@ivar: Holds customer-specified transaction IDs.\"\"\"\r\n\r\n self.__set_web_authentication_detail()\r\n self.__set_client_detail()\r\n self.__set_version_id()\r\n self.__set_transaction_detail(*args, **kwargs)\r\n self._prepare_wsdl_objects()","def __init__(self, use=True):\n self.use = use","def _create_soap_object(self, name):\n return self.client.factory.create(name)","def __init__(self, enable_gateway=False, topology_name=None, topologies=None, exposed_services=None, token_cert=None, gateway_type=None, sso_type=None):\n\n self._enable_gateway = None\n self._topology_name = None\n self._topologies = None\n self._exposed_services = None\n self._token_cert = None\n self._gateway_type = None\n self._sso_type = None\n\n if enable_gateway is not None:\n self.enable_gateway = enable_gateway\n if topology_name is not None:\n self.topology_name = topology_name\n if topologies is not None:\n self.topologies = topologies\n if exposed_services is not None:\n self.exposed_services = exposed_services\n if token_cert is not None:\n self.token_cert = token_cert\n if gateway_type is not None:\n self.gateway_type = gateway_type\n if sso_type is not None:\n self.sso_type = sso_type","def given_an_instance() -> machine_learning.StationMachineLearning:\n # super weird bug? with pytest_bdd that hooked into isoformat on the coordinate and points fields.\n # tried forever to figure out why - and gave up in the end. removed coordinate and point from\n # feature file and just loading it in here.\n coordinate = _load_json_file(__file__, 'coordinate.json')\n points = _load_json_file(__file__, 'points.json')\n return machine_learning.StationMachineLearning(\n session=None,\n model=PredictionModel(id=1),\n grid=PredictionModelGridSubset(id=1),\n points=points,\n target_coordinate=coordinate,\n station_code=None,\n max_learn_date=datetime.now())","def validate_is_instance(var: Any,\n var_name: str,\n instance_type: Any,\n class_name: Optional[str] = None,\n log_metadata_validation_failures: bool = True) -> None:\n if var is None:\n return\n splits = str(instance_type).split(\" 1:\n print_type = splits[1]\n else:\n print_type = splits[0]\n if log_metadata_validation_failures:\n if class_name is None:\n logging.debug(\n \"XAI Validation :: Metadata: Variable `%s` should be of type `%s`\",\n var_name, print_type)\n else:\n logging.debug(\n \"XAI Validation :: Metadata: [%s] Variable `%s` should be of type \"\n \"`%s`\", class_name, var_name, print_type)\n if not isinstance(var, instance_type):\n raise TypeError(\"{} must be of type {}. Got {}\".format(\n var_name, str(instance_type), str(type(var))))","def __init__(self, data):\n self.jssp_instance_data = data","def load_instance(self, instance_path, input_shapes):\n metadata = load_json(os.path.join(instance_path, 'instance.meta'))\n self.log('load metadata')\n\n instance_class_name = metadata[MODEL_METADATA_KEY_INSTANCE_CLASS_NAME]\n instance_source_path = metadata[MODEL_METADATA_KEY_INSTANCE_SOURCE_PATH]\n model = import_class_from_module_path(instance_source_path, instance_class_name)\n self.log('instance source code load')\n\n self.instance = model(metadata[MODEL_METADATA_KEY_INSTANCE_PATH])\n self.instance.load_model(metadata, input_shapes)\n self.log('load instance')\n\n instance_id = metadata[MODEL_METADATA_KEY_INSTANCE_ID]\n self.log('load instance id : %s' % instance_id)","def _prepare_wsdl_objects(self):\r\n self.TrackPackageIdentifier = self.client.factory.create('TrackPackageIdentifier')\r\n # Default to tracking number.\r\n self.TrackPackageIdentifier.Type = 'TRACKING_NUMBER_OR_DOORTAG'","def __init__(self, api_use=False):\n self.api_use = api_use","def from_url(cls, wsdl_path):\n return cls(safe_parse_url(wsdl_path))","def create_instance(c_instance):\n\treturn 0","def __init__(self, services, tns):\r\n\r\n return super(DjangoSoapApp, self).__init__(Application(services, tns))","def __init__(self, py_dict=None):\n super(EdgeNATRulesSchema, self).__init__()\n self.set_data_type('xml')\n self.natRule = EdgeNATRuleSchema()\n\n if py_dict is not None:\n self.get_object_from_py_dict(py_dict)","def _prepare_wsdl_objects(self):\r\n\r\n\t# Default behavior is to not request transit information\r\n\tself.ReturnTransitAndCommit = False\r\n\r\n # This is the primary data structure for processShipment requests.\r\n self.RequestedShipment = self.client.factory.create('RequestedShipment')\r\n self.RequestedShipment.ShipTimestamp = datetime.now()\r\n \r\n TotalWeight = self.client.factory.create('Weight')\r\n # Start at nothing.\r\n TotalWeight.Value = 0.0\r\n # Default to pounds.\r\n TotalWeight.Units = 'LB'\r\n # This is the total weight of the entire shipment. Shipments may\r\n # contain more than one package.\r\n self.RequestedShipment.TotalWeight = TotalWeight\r\n \r\n # This is the top level data structure for Shipper information.\r\n ShipperParty = self.client.factory.create('Party')\r\n ShipperParty.Address = self.client.factory.create('Address')\r\n ShipperParty.Contact = self.client.factory.create('Contact')\r\n \r\n # Link the ShipperParty to our master data structure.\r\n self.RequestedShipment.Shipper = ShipperParty\r\n\r\n # This is the top level data structure for Recipient information.\r\n RecipientParty = self.client.factory.create('Party')\r\n RecipientParty.Contact = self.client.factory.create('Contact')\r\n RecipientParty.Address = self.client.factory.create('Address')\r\n \r\n # Link the RecipientParty object to our master data structure.\r\n self.RequestedShipment.Recipient = RecipientParty\r\n \r\n Payor = self.client.factory.create('Payor')\r\n # Grab the account number from the FedexConfig object by default.\r\n Payor.AccountNumber = self._config_obj.account_number\r\n # Assume US.\r\n Payor.CountryCode = 'US'\r\n \r\n ShippingChargesPayment = self.client.factory.create('Payment')\r\n ShippingChargesPayment.Payor = Payor\r\n\r\n self.RequestedShipment.ShippingChargesPayment = ShippingChargesPayment\r\n \r\n # ACCOUNT or LIST\r\n self.RequestedShipment.RateRequestTypes = ['ACCOUNT'] \r\n \r\n # Start with no packages, user must add them.\r\n self.RequestedShipment.PackageCount = 0\r\n self.RequestedShipment.RequestedPackageLineItems = []\r\n \r\n # This is good to review if you'd like to see what the data structure\r\n # looks like.\r\n self.logger.debug(self.RequestedShipment)","def test_hidden_instantiate(self):\n context = self.framework.get_bundle_context()\n\n # Prepare random values\n hidden_value = random.randint(0, 100)\n public_value = random.randint(0, 100)\n\n # Instantiate the component\n with use_ipopo(context) as ipopo:\n svc = ipopo.instantiate(self.module.FACTORY_HIDDEN_PROPS, NAME_A,\n {\"hidden.prop\": hidden_value,\n \"public.prop\": public_value})\n\n # Check default values (and accesses)\n self.assertEqual(svc.hidden, hidden_value)\n self.assertEqual(svc.public, public_value)\n\n # Check instance details\n with use_ipopo(context) as ipopo:\n details = ipopo.get_instance_details(NAME_A)\n\n self.assertNotIn(\"hidden.prop\", details[\"properties\"])","def make_instance(self, data, **kwargs):\n instance = self.instance or self.get_instance(data)\n if instance is not None:\n for key, value in iteritems(data):\n setattr(instance, key, value)\n return instance\n kwargs, association_attrs = self._split_model_kwargs_association(data)\n instance = self.opts.model(**kwargs)\n for attr, value in iteritems(association_attrs):\n setattr(instance, attr, value)\n return instance","def use_instance_table(self, name, typename):\n if typename in ['VkInstance', 'VkPhysicalDevice']:\n return True\n # vkSetDebugUtilsObjectNameEXT and vkSetDebugUtilsObjectTagEXT\n # need to be probed from GetInstanceProcAddress due to a loader issue.\n # https://github.com/KhronosGroup/Vulkan-Loader/issues/1109\n # TODO : When loader with fix for issue is widely available, remove this\n # special case.\n if name in ['vkSetDebugUtilsObjectNameEXT', 'vkSetDebugUtilsObjectTagEXT']:\n return True\n return False","def create_instance(c_instance):\n return OpenLabs(c_instance)","def build_from_mongo(cls, data, use_cls=True):\n # If a _cls is specified, we have to use this document class\n if use_cls and '_cls' in data:\n cls = cls.opts.instance.retrieve_embedded_document(data['_cls'])\n doc = cls()\n doc.from_mongo(data)\n return doc","def from_file(cls, wsdl_path):\n return cls(safe_parse_path(wsdl_path))","def ontology_instance(self,target=None,path=None,value=None,**kwargs):\n\n if target == None or path == None or value == None:\n print(\"Usage: ontology_instance target path value\",file=sys.stderr)\n sys.exit(2)\n\n force = kwargs.get('force')\n\n payload={\"path\":path,\"value\":value}\n if force:\n r=self.put(self.ONTOLOGY_INSTANCE_RT,target,payload,**kwargs)\n else:\n r=self.post(self.ONTOLOGY_INSTANCE_RT,None,target,payload,**kwargs)\n\n return r","def add_instance(\n self,\n name,\n base_config_dir=None,\n main_configs=None,\n user_configs=None,\n dictionaries=None,\n macros=None,\n with_zookeeper=False,\n with_zookeeper_secure=False,\n with_mysql_client=False,\n with_mysql=False,\n with_mysql8=False,\n with_mysql_cluster=False,\n with_kafka=False,\n with_kerberized_kafka=False,\n with_kerberos_kdc=False,\n with_secrets=False,\n with_rabbitmq=False,\n with_nats=False,\n clickhouse_path_dir=None,\n with_odbc_drivers=False,\n with_postgres=False,\n with_postgres_cluster=False,\n with_postgresql_java_client=False,\n clickhouse_log_file=CLICKHOUSE_LOG_FILE,\n clickhouse_error_log_file=CLICKHOUSE_ERROR_LOG_FILE,\n with_hdfs=False,\n with_kerberized_hdfs=False,\n with_mongo=False,\n with_mongo_secure=False,\n with_meili=False,\n with_nginx=False,\n with_redis=False,\n with_minio=False,\n with_azurite=False,\n with_cassandra=False,\n with_jdbc_bridge=False,\n with_hive=False,\n with_coredns=False,\n allow_analyzer=True,\n hostname=None,\n env_variables=None,\n image=\"clickhouse/integration-test\",\n tag=None,\n stay_alive=False,\n ipv4_address=None,\n ipv6_address=None,\n with_installed_binary=False,\n external_dirs=None,\n tmpfs=None,\n zookeeper_docker_compose_path=None,\n minio_certs_dir=None,\n minio_data_dir=None,\n use_keeper=True,\n main_config_name=\"config.xml\",\n users_config_name=\"users.xml\",\n copy_common_configs=True,\n config_root_name=\"clickhouse\",\n extra_configs=[],\n ) -> \"ClickHouseInstance\":\n\n if self.is_up:\n raise Exception(\"Can't add instance %s: cluster is already up!\" % name)\n\n if name in self.instances:\n raise Exception(\n \"Can't add instance `%s': there is already an instance with the same name!\"\n % name\n )\n\n if tag is None:\n tag = self.docker_base_tag\n if not env_variables:\n env_variables = {}\n\n self.use_keeper = use_keeper\n\n # Code coverage files will be placed in database directory\n # (affect only WITH_COVERAGE=1 build)\n env_variables[\n \"LLVM_PROFILE_FILE\"\n ] = \"/var/lib/clickhouse/server_%h_%p_%m.profraw\"\n\n clickhouse_start_command = CLICKHOUSE_START_COMMAND\n if clickhouse_log_file:\n clickhouse_start_command += \" --log-file=\" + clickhouse_log_file\n if clickhouse_error_log_file:\n clickhouse_start_command += \" --errorlog-file=\" + clickhouse_error_log_file\n logging.debug(f\"clickhouse_start_command: {clickhouse_start_command}\")\n\n instance = ClickHouseInstance(\n cluster=self,\n base_path=self.base_dir,\n name=name,\n base_config_dir=base_config_dir\n if base_config_dir\n else self.base_config_dir,\n custom_main_configs=main_configs or [],\n custom_user_configs=user_configs or [],\n custom_dictionaries=dictionaries or [],\n macros=macros or {},\n with_zookeeper=with_zookeeper,\n zookeeper_config_path=self.zookeeper_config_path,\n with_mysql_client=with_mysql_client,\n with_mysql=with_mysql,\n with_mysql8=with_mysql8,\n with_mysql_cluster=with_mysql_cluster,\n with_kafka=with_kafka,\n with_kerberized_kafka=with_kerberized_kafka,\n with_kerberos_kdc=with_kerberos_kdc,\n with_rabbitmq=with_rabbitmq,\n with_nats=with_nats,\n with_nginx=with_nginx,\n with_kerberized_hdfs=with_kerberized_hdfs,\n with_secrets=with_secrets\n or with_kerberized_hdfs\n or with_kerberos_kdc\n or with_kerberized_kafka,\n with_mongo=with_mongo or with_mongo_secure,\n with_meili=with_meili,\n with_redis=with_redis,\n with_minio=with_minio,\n with_azurite=with_azurite,\n with_jdbc_bridge=with_jdbc_bridge,\n with_hive=with_hive,\n with_coredns=with_coredns,\n with_cassandra=with_cassandra,\n allow_analyzer=allow_analyzer,\n server_bin_path=self.server_bin_path,\n odbc_bridge_bin_path=self.odbc_bridge_bin_path,\n library_bridge_bin_path=self.library_bridge_bin_path,\n clickhouse_path_dir=clickhouse_path_dir,\n with_odbc_drivers=with_odbc_drivers,\n with_postgres=with_postgres,\n with_postgres_cluster=with_postgres_cluster,\n with_postgresql_java_client=with_postgresql_java_client,\n clickhouse_start_command=clickhouse_start_command,\n main_config_name=main_config_name,\n users_config_name=users_config_name,\n copy_common_configs=copy_common_configs,\n hostname=hostname,\n env_variables=env_variables,\n image=image,\n tag=tag,\n stay_alive=stay_alive,\n ipv4_address=ipv4_address,\n ipv6_address=ipv6_address,\n with_installed_binary=with_installed_binary,\n external_dirs=external_dirs,\n tmpfs=tmpfs or [],\n config_root_name=config_root_name,\n extra_configs=extra_configs,\n )\n\n docker_compose_yml_dir = get_docker_compose_path()\n\n self.instances[name] = instance\n if ipv4_address is not None or ipv6_address is not None:\n self.with_net_trics = True\n self.base_cmd.extend(\n [\"--file\", p.join(docker_compose_yml_dir, \"docker_compose_net.yml\")]\n )\n\n self.base_cmd.extend([\"--file\", instance.docker_compose_path])\n\n cmds = []\n if with_zookeeper_secure and not self.with_zookeeper_secure:\n cmds.append(\n self.setup_zookeeper_secure_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_zookeeper and not self.with_zookeeper:\n if self.use_keeper:\n cmds.append(\n self.setup_keeper_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n else:\n cmds.append(\n self.setup_zookeeper_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_mysql_client and not self.with_mysql_client:\n cmds.append(\n self.setup_mysql_client_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_mysql and not self.with_mysql:\n cmds.append(\n self.setup_mysql_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_mysql8 and not self.with_mysql8:\n cmds.append(\n self.setup_mysql8_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_mysql_cluster and not self.with_mysql_cluster:\n cmds.append(\n self.setup_mysql_cluster_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_postgres and not self.with_postgres:\n cmds.append(\n self.setup_postgres_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_postgres_cluster and not self.with_postgres_cluster:\n cmds.append(\n self.setup_postgres_cluster_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_postgresql_java_client and not self.with_postgresql_java_client:\n cmds.append(\n self.setup_postgresql_java_client_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_odbc_drivers and not self.with_odbc_drivers:\n self.with_odbc_drivers = True\n if not self.with_mysql:\n cmds.append(\n self.setup_mysql_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if not self.with_postgres:\n cmds.append(\n self.setup_postgres_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_kafka and not self.with_kafka:\n cmds.append(\n self.setup_kafka_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_kerberized_kafka and not self.with_kerberized_kafka:\n cmds.append(\n self.setup_kerberized_kafka_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_kerberos_kdc and not self.with_kerberos_kdc:\n cmds.append(\n self.setup_kerberos_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_rabbitmq and not self.with_rabbitmq:\n cmds.append(\n self.setup_rabbitmq_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_nats and not self.with_nats:\n cmds.append(\n self.setup_nats_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_nginx and not self.with_nginx:\n cmds.append(\n self.setup_nginx_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_hdfs and not self.with_hdfs:\n cmds.append(\n self.setup_hdfs_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_kerberized_hdfs and not self.with_kerberized_hdfs:\n cmds.append(\n self.setup_kerberized_hdfs_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if (with_mongo or with_mongo_secure) and not (\n self.with_mongo or self.with_mongo_secure\n ):\n if with_mongo_secure:\n cmds.append(\n self.setup_mongo_secure_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n else:\n cmds.append(\n self.setup_mongo_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_coredns and not self.with_coredns:\n cmds.append(\n self.setup_coredns_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_meili and not self.with_meili:\n cmds.append(\n self.setup_meili_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if self.with_net_trics:\n for cmd in cmds:\n cmd.extend(\n [\"--file\", p.join(docker_compose_yml_dir, \"docker_compose_net.yml\")]\n )\n\n if with_redis and not self.with_redis:\n cmds.append(\n self.setup_redis_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_minio and not self.with_minio:\n cmds.append(\n self.setup_minio_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if with_azurite and not self.with_azurite:\n cmds.append(\n self.setup_azurite_cmd(instance, env_variables, docker_compose_yml_dir)\n )\n\n if minio_certs_dir is not None:\n if self.minio_certs_dir is None:\n self.minio_certs_dir = minio_certs_dir\n else:\n raise Exception(\"Overwriting minio certs dir\")\n\n if minio_data_dir is not None:\n if self.minio_data_dir is None:\n self.minio_data_dir = minio_data_dir\n else:\n raise Exception(\"Overwriting minio data dir\")\n\n if with_cassandra and not self.with_cassandra:\n cmds.append(\n self.setup_cassandra_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_jdbc_bridge and not self.with_jdbc_bridge:\n cmds.append(\n self.setup_jdbc_bridge_cmd(\n instance, env_variables, docker_compose_yml_dir\n )\n )\n\n if with_hive:\n cmds.append(\n self.setup_hive(instance, env_variables, docker_compose_yml_dir)\n )\n\n logging.debug(\n \"Cluster name:{} project_name:{}. Added instance name:{} tag:{} base_cmd:{} docker_compose_yml_dir:{}\".format(\n self.name,\n self.project_name,\n name,\n tag,\n self.base_cmd,\n docker_compose_yml_dir,\n )\n )\n return instance","def __init__(self):\n\t\tself.parsed = False\n\t\tdir_path = os.path.dirname(os.path.realpath(__file__))\n\t\tself.xsdfilename = os.path.join(dir_path, 'xml', 'schema.xsd')\n\t\tself.schema = 'schema.xsd'\n\t\tself.predictors = []\n\t\tself.predictors_types = []\n\t\tself.preprocessing_methods = []","def _prepare_wsdl_objects(self):\r\n # This is the primary data structure for processShipment requests.\r\n self.RequestedShipment = self.client.factory.create('RequestedShipment')\r\n self.RequestedShipment.ShipTimestamp = datetime.now()\r\n \r\n TotalWeight = self.client.factory.create('Weight')\r\n # Start at nothing.\r\n TotalWeight.Value = 0.0\r\n # Default to pounds.\r\n TotalWeight.Units = 'LB'\r\n # This is the total weight of the entire shipment. Shipments may\r\n # contain more than one package.\r\n self.RequestedShipment.TotalWeight = TotalWeight\r\n \r\n # This is the top level data structure for Shipper information.\r\n ShipperParty = self.client.factory.create('Party')\r\n ShipperParty.Address = self.client.factory.create('Address')\r\n ShipperParty.Contact = self.client.factory.create('Contact')\r\n \r\n # Link the ShipperParty to our master data structure.\r\n self.RequestedShipment.Shipper = ShipperParty\r\n\r\n # This is the top level data structure for Recipient information.\r\n RecipientParty = self.client.factory.create('Party')\r\n RecipientParty.Contact = self.client.factory.create('Contact')\r\n RecipientParty.Address = self.client.factory.create('Address')\r\n \r\n # Link the RecipientParty object to our master data structure.\r\n self.RequestedShipment.Recipient = RecipientParty\r\n \r\n Payor = self.client.factory.create('Payor')\r\n # Grab the account number from the FedexConfig object by default.\r\n Payor.AccountNumber = self._config_obj.account_number\r\n # Assume US.\r\n Payor.CountryCode = 'US'\r\n \r\n ShippingChargesPayment = self.client.factory.create('Payment')\r\n ShippingChargesPayment.Payor = Payor\r\n\r\n self.RequestedShipment.ShippingChargesPayment = ShippingChargesPayment\r\n self.RequestedShipment.LabelSpecification = self.client.factory.create('LabelSpecification')\r\n # ACCOUNT or LIST\r\n self.RequestedShipment.RateRequestTypes = ['ACCOUNT'] \r\n \r\n # Start with no packages, user must add them.\r\n self.RequestedShipment.PackageCount = 0\r\n self.RequestedShipment.RequestedPackageLineItems = []\r\n \r\n # This is good to review if you'd like to see what the data structure\r\n # looks like.\r\n self.logger.debug(self.RequestedShipment)","def __init__(self, name, pair_instance, dof_cls):\n self._name = name\n self._dof_cls = dof_cls\n self._pair_instance = pair_instance\n self._indexer = hoomd.data.parameterdicts._SmartTypeIndexer(2)\n self._data = {}","def load_class_variables(cls, app_configs):\n cls.is_connected = False # Set is_connected to false initially\n \n validate_fields(['sdlp_host', 'sdlp_wsdl', 'sdlp_username', 'sdlp_password', 'sdlp_savedreportid', 'sdlp_incident_endpoint'], kwargs=app_configs)\n\n LOG.debug(\"Validated Mandatory app.configs for DLPSoapClient\")\n\n cls.host = app_configs.get('sdlp_host')\n cls.wsdl = app_configs.get('sdlp_wsdl')\n # Gather the DLP User Name\n cls.dlp_username = app_configs.get('sdlp_username')\n # Gather the DLP User Password\n cls.dlp_password = app_configs.get('sdlp_password')\n\n # Gather the DLP Cert\n cls.dlp_cert = app_configs.get('sdlp_cafile', False)\n\n # Gather the DLP Saved Report ID\n cls.dlp_saved_report_id = app_configs.get('sdlp_savedreportid')\n\n # Gather the DLP Incident Endpoint\n cls.sdlp_incident_endpoint = app_configs.get('sdlp_incident_endpoint')\n\n cls.session = Session()\n # Use DLP Cert if provided or if None, set verify to false\n cls.session.verify = cls.dlp_cert\n cls.session.auth = SymantecAuth(cls.dlp_username, cls.dlp_password, cls.host)\n\n\n mimefile_abs_path = os.path.join(\n os.path.dirname(os.path.realpath(__file__)),\n os.path.pardir, \"data\", \"xmlmime.xml\")\n # If the Xmlmime file was provided\n if os.path.isfile(mimefile_abs_path):\n LOG.info(\"A Local XML file was found in the data directory, %s \\n Loading this into the cache\", mimefile_abs_path)\n # Open it and add it to a Cache\n with open(mimefile_abs_path, mode=\"rb\") as f:\n filecontent = f.read()\n dlp_cache = InMemoryCache()\n dlp_cache.add(\"http://www.w3.org/2005/05/xmlmime\", filecontent)\n dlp_cache.add(\"https://www.w3.org/2005/05/xmlmime\", filecontent)\n # Setup Transport with credentials and the cached mimefile\n cls.transport = zeep.Transport(session=cls.session, cache=dlp_cache)\n else:\n # Setup Transport with our credentials\n cls.transport = zeep.Transport(session=cls.session)\n\n try: # Try to create a soap_client from the wsdl and transport\n cls.soap_client = zeep.Client(wsdl=cls.wsdl, transport=cls.transport)\n except Exception as caught_exc: # We got an error when setting up a client, catch and release the error in logs so circuits doesn't stop\n # Put the traceback into DEBUG\n LOG.debug(traceback.format_exc())\n # Log the Connection error to the user\n LOG.error(u\"Problem: %s\", repr(caught_exc))\n LOG.error(u\"[Symantec DLP] Encountered an exception when setting up the SOAP Client\")\n \n else: # No connection error, client is setup with the URL. Allow the poller to be setup\n cls.is_connected = True\n cls.class_vars_loaded = True","def create_client(wsdl: str, raw_response: bool = True) -> CachingClient:\n # We want the raw response as there is an error when Zeep parses the XML\n settings: Settings = Settings(raw_response=raw_response)\n\n # Client that caches the WSDL\n client: CachingClient = CachingClient(\n wsdl=wsdl,\n # TODO: Store PW encrypted\n wsse=UsernameToken(\"n00394gz\", \"g427Ix19LMB\"),\n settings=settings,\n )\n logger.debug(f\"Client created\")\n\n return client","def test_instantiation(self):\n classifier = WidgetClassifier()\n classifier.load_model()\n assert(classifier.encoder is not None)\n assert(classifier.cluster is not None)\n assert(classifier.telemetry_keys is not None)","def from_dict(data, decomposer_=None, rx=None, ax=None):\n if decomposer_ is not None:\n decomposer = decomposer_\n else:\n decomposer = SOAPDecomposer(**data[\"decomposer\"])\n \n result = SOAPVector(data[\"P\"], decomposer)\n result.dcP = data[\"dcP\"]\n result.dnP = data[\"dnP\"]\n if rx is not None and data[\"rx\"] is None:# pragma: no cover\n result.rx = rx\n else:\n result.rx = data[\"rx\"]\n if ax is not None and data[\"ax\"] is None:# pragma: no cover\n result.ax = ax\n else:\n result.ax = data[\"ax\"]\n \n if data[\"cRDF\"] is not None:\n result.cRDF = DF(data[\"dcP\"], True, result.rx, decomposer,\n calculate=False)\n result.cRDF.df = data[\"cRDF\"]\n if data[\"nRDF\"] is not None:\n result.nRDF = DF(data[\"dnP\"], False, result.rx, decomposer,\n calculate=False)\n result.nRDF.df = data[\"nRDF\"]\n if data[\"cADF\"] is not None:\n result.cADF = DF(data[\"dcP\"], True, result.ax, decomposer,\n calculate=False)\n result.cADF.df = data[\"cADF\"]\n if data[\"nADF\"] is not None:\n result.nADF = DF(data[\"dnP\"], False, result.ax, decomposer,\n calculate=False)\n result.nADF.df = data[\"nADF\"]\n\n return result","def test_instanceBuilder(self):\n instance = igwt.IInstanceFactory(ChangeType()).buildInstance()\n self.assertTrue(instance is not None)\n self.assertTrue(isinstance(instance, Change))","def newInstance(self, isTraining):\r\n #-------------------------------------------------------\r\n # Training Data\r\n #-------------------------------------------------------\r\n if isTraining: \r\n if self.dataRef < (self.formatData.numTrainInstances-1):\r\n self.dataRef += 1\r\n self.currentTrainState = self.formatData.trainFormatted[self.dataRef][0]\r\n self.currentTrainPhenotype = self.formatData.trainFormatted[self.dataRef][1]\r\n\r\n else: #Once learning has completed an epoch (i.e. learning iterations though the entire dataset) it starts back at the first instance in the data)\r\n self.resetDataRef(isTraining)\r\n #-------------------------------------------------------\r\n # Testing Data\r\n #-------------------------------------------------------\r\n else: \r\n if self.dataRef < (self.formatData.numTestInstances-1):\r\n self.dataRef += 1\r\n self.currentTestState = self.formatData.testFormatted[self.dataRef][0]\r\n self.currentTestPhenotype = self.formatData.testFormatted[self.dataRef][1]","def load(self, data, session=None, instance=None, transient=False, *args, **kwargs):\n self._session = session or self._session\n self._transient = transient or self._transient\n if not (self.transient or self.session):\n raise ValueError(\"Deserialization requires a session\")\n self.instance = instance or self.instance\n try:\n return super(ModelSchema, self).load(data, *args, **kwargs)\n finally:\n self.instance = None","def get_single_ns_info(self, ns_inst, is_sol=False):\n if is_sol:\n nsInstance = {}\n nsInstance['id'] = ns_inst.id\n nsInstance['nsInstanceName'] = ns_inst.name\n nsInstance['nsInstanceDescription'] = ns_inst.description\n nsInstance['nsdId'] = ns_inst.nsd_id\n nsInstance['nsdInfoId'] = ns_inst.nspackage_id\n nsInstance['nsState'] = ns_inst.status\n if ns_inst.nsd_invariant_id:\n nsInstance['nsdInvariantId'] = ns_inst.nsd_invariant_id\n if ns_inst.flavour_id:\n nsInstance['flavourId'] = ns_inst.flavour_id\n # todo 'nsScaleStatus':{}\n # todo 'additionalAffinityOrAntiAffinityRule':{}\n logger.debug(\" test \")\n vnf_instance_list = self.get_vnf_infos(ns_inst.id, is_sol)\n if vnf_instance_list:\n nsInstance['vnfInstance'] = vnf_instance_list\n # todo 'pnfInfo': self.get_pnf_infos(ns_inst.id,is_sol),\n vl_list = self.get_vl_infos(ns_inst.id, is_sol)\n if vl_list:\n nsInstance['virtualLinkInfo'] = vl_list\n # todo 'vnffgInfo': self.get_vnffg_infos(ns_inst.id, ns_inst.nsd_model),\n # todo 'sapInfo':{},\n # todo nestedNsInstanceId\n logger.debug(\" test \")\n nsInstance['_links'] = {\n 'self': {'href': NS_INSTANCE_BASE_URI % ns_inst.id},\n 'instantiate': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/instantiate'},\n 'terminate': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/terminate'},\n 'update': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/update'},\n 'scale': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/scale'},\n 'heal': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/heal'}\n }\n logger.debug(\" test \")\n return nsInstance\n return {\n 'nsInstanceId': ns_inst.id,\n 'nsName': ns_inst.name,\n 'description': ns_inst.description,\n 'nsdId': ns_inst.nsd_id,\n 'nsdInvariantId': ns_inst.nsd_invariant_id,\n 'vnfInfo': self.get_vnf_infos(ns_inst.id, is_sol),\n 'pnfInfo': self.get_pnf_infos(ns_inst.id),\n 'vlInfo': self.get_vl_infos(ns_inst.id, is_sol),\n 'vnffgInfo': self.get_vnffg_infos(ns_inst.id, ns_inst.nsd_model, is_sol),\n 'nsState': ns_inst.status}","def _get_instance(self):","def _get_instance(self):","def create_instance(self, date):\n raise NotImplementedError","def create_instance(self, **attrs):\n return self._create(_instance.Instance, **attrs)","def create(self):\n raise WufooException(\"InstanceResource creation not supported\")","def __init__(self):\n self.id = None\n \"\"\"\"true if individual services can be enabled/disabled\"\"\"\n self.canenableindividualservice = None\n \"\"\"\"the destination physical network\"\"\"\n self.destinationphysicalnetworkid = None\n \"\"\"\"the provider name\"\"\"\n self.name = None\n \"\"\"\"the physical network this belongs to\"\"\"\n self.physicalnetworkid = None\n \"\"\"\"services for this provider\"\"\"\n self.servicelist = None\n \"\"\"\"state of the network provider\"\"\"\n self.state = None","def _is_dataclass_instance(obj):\n return hasattr(type(obj), '__dataclass_fields__')","def do_instance_start(self, component_handle, instance_handle):\n logger.debug(\"RwdtstaskletPython: do_instance_start function called\")\n\n # Create an instance of DTS API - This object is needed by all DTS\n # member and query APIs directly or indirectly.\n # DTS invokes the callback to notify the tasklet that the DTS API instance is ready \n # for use.\n\n foo = Callback()\n #sub = SubscribeInsideXactExample(self)\n self.dts_api = RwDts.Api.new(self.taskletinfo, # tasklet object\n RwDtsToyTaskletYang.get_schema(), # Schema object\n foo.rwdts_tasklet_state_change_cb, # The callback for DTS state change\n #sub.rwdts_tasklet_state_change_cb,\n self) # user data in the callback - in this case self","def __init__(self, dry_run=False):\n\t\t# TODO(jchaloup):\n\t\t# - inject the product together with buildsystem client\n\t\t# TODO(jchaloup):\n\t\t# - inject the act and replace it with datasource instead\n\t\t# so the artefact/data can be picked from more sources","def prepare_instance(self, idx):\n instance = self.instances[idx]\n component = instance['components'][0]\n \n results = self.prepare_component(instance, component,instance['dec_per'])\n return results","def GetInstance():\n pass","def __init__(self):\n self.swagger_types = {\n 'id_conta': 'int',\n 'id_produto': 'int',\n 'id_pessoa': 'int',\n 'id_parentesco': 'int',\n 'tipo_portador': 'str',\n 'nome_impresso': 'str',\n 'id_tipo_cartao': 'int',\n 'flag_ativo': 'int',\n 'data_cadastro_portador': 'str',\n 'data_cancelamento_portador': 'str'\n }\n\n self.attribute_map = {\n 'id_conta': 'idConta',\n 'id_produto': 'idProduto',\n 'id_pessoa': 'idPessoa',\n 'id_parentesco': 'idParentesco',\n 'tipo_portador': 'tipoPortador',\n 'nome_impresso': 'nomeImpresso',\n 'id_tipo_cartao': 'idTipoCartao',\n 'flag_ativo': 'flagAtivo',\n 'data_cadastro_portador': 'dataCadastroPortador',\n 'data_cancelamento_portador': 'dataCancelamentoPortador'\n }\n\n self._id_conta = None\n self._id_produto = None\n self._id_pessoa = None\n self._id_parentesco = None\n self._tipo_portador = None\n self._nome_impresso = None\n self._id_tipo_cartao = None\n self._flag_ativo = None\n self._data_cadastro_portador = None\n self._data_cancelamento_portador = None","def __init__(self, instance=None):\n self.instance = instance\n self.schema = None\n if self.instance:\n self.schema = surveys.SurveySchema(self.instance.survey)","def _new_instance(cls, data, wcs, errors=None, **kwargs):\n return cls(data, wcs, errors=errors, **kwargs)","def __init__(self, py_dict=None):\n super(TypeSchema, self).__init__()\n self.set_data_type('xml')\n\n self.typeName = None","def __call__(self,setup_options=True, instantiate_options=True, verbose=False):\n model = self.setup(setup_options)\n model(instantiate_options, verbose)\n return model","def __init__(self, py_dict=None):\n super(PagedSystemEventListSchema, self).__init__()\n self.set_data_type(\"xml\")\n self.dataPage = DataPageSchema()\n\n\n if py_dict is not None:\n self.get_object_from_py_dict(py_dict)","def create_instance(self, data_defs):\n if not data_defs:\n msg = 'No data definitions are provided.'\n raise AppResponseException(msg)\n\n if (any(dd.source.name == 'packets' for dd in data_defs)\n and any(dd.source.name != 'packets' for dd in data_defs)):\n # Two report instance needs to be created, one uses 'npm.reports'\n # service, the other one uses 'npm.probe.reports' service\n # it would create unnecessary complexity to support this case\n # thus report error and let the user to create two separate\n # report instances\n\n msg = ('Both packets data source and non-packets data source are '\n 'being queried in this report, which is not supported. The '\n 'data source names include {}'\n .format(', '.join(set([dd.source.name\n for dd in data_defs]))))\n raise AppResponseException(msg)\n\n def _create_and_run(service_name, data_defs):\n\n config = dict(data_defs=[dd.to_dict() for dd in data_defs])\n logger.debug(\"Creating instance with data definitions %s\" % config)\n\n svcdef = self.appresponse.find_service(service_name)\n datarep = svcdef.bind('instances')\n resp = datarep.execute('create', _data=config)\n\n instance = ReportInstance(data=resp.data, datarep=resp)\n while not instance.is_complete():\n time.sleep(1)\n\n if instance.errors:\n err_msgs = ';\\n'.join(instance.errors)\n raise AppResponseException(err_msgs)\n\n return instance\n\n if data_defs[0].source.name == 'packets':\n # Needs to create a clip for for capture job packets source\n # Keep the clip till the instance is completed\n with self.appresponse.clips.create_clips(data_defs):\n # capture job data_defs are modified in place\n instance = _create_and_run(PACKETS_REPORT_SERVICE_NAME,\n data_defs)\n else:\n instance = _create_and_run(GENERAL_REPORT_SERVICE_NAME,\n data_defs)\n return instance","def create(self, validated_data):\n security_groups = validated_data.pop('security_groups', [])\n internal_ips = validated_data.pop('internal_ips_set', [])\n floating_ips_with_subnets = validated_data.pop('floating_ips', [])\n spl = validated_data['service_project_link']\n ssh_key = validated_data.get('ssh_public_key')\n if ssh_key:\n # We want names to be human readable in backend.\n # OpenStack only allows latin letters, digits, dashes, underscores and spaces\n # as key names, thus we mangle the original name.\n safe_name = re.sub(r'[^-a-zA-Z0-9 _]+', '_', ssh_key.name)[:17]\n validated_data['key_name'] = '{0}-{1}'.format(ssh_key.uuid.hex, safe_name)\n validated_data['key_fingerprint'] = ssh_key.fingerprint\n\n flavor = validated_data['flavor']\n validated_data['flavor_name'] = flavor.name\n validated_data['cores'] = flavor.cores\n validated_data['ram'] = flavor.ram\n validated_data['flavor_disk'] = flavor.disk\n\n image = validated_data['image']\n validated_data['image_name'] = image.name\n validated_data['min_disk'] = image.min_disk\n validated_data['min_ram'] = image.min_ram\n\n system_volume_size = validated_data['system_volume_size']\n data_volume_size = validated_data.get('data_volume_size', 0)\n validated_data['disk'] = data_volume_size + system_volume_size\n\n instance = super(InstanceSerializer, self).create(validated_data)\n\n # security groups\n instance.security_groups.add(*security_groups)\n # internal IPs\n for internal_ip in internal_ips:\n internal_ip.instance = instance\n internal_ip.save()\n # floating IPs\n for floating_ip, subnet in floating_ips_with_subnets:\n _connect_floating_ip_to_instance(floating_ip, subnet, instance)\n # volumes\n volumes = []\n system_volume = models.Volume.objects.create(\n name='{0}-system'.format(instance.name[:143]), # volume name cannot be longer than 150 symbols\n service_project_link=spl,\n size=system_volume_size,\n image=image,\n image_name=image.name,\n bootable=True,\n )\n volumes.append(system_volume)\n\n if data_volume_size:\n data_volume = models.Volume.objects.create(\n name='{0}-data'.format(instance.name[:145]), # volume name cannot be longer than 150 symbols\n service_project_link=spl,\n size=data_volume_size,\n )\n volumes.append(data_volume)\n\n for volume in volumes:\n volume.increase_backend_quotas_usage()\n\n instance.volumes.add(*volumes)\n return instance","def __init__(self, doc: Dict, validate: Optional[bool] = True):\n self.doc = doc\n if validate:\n jsonschema.validate(instance=doc, schema=DESCRIPTOR_SCHEMA)","def __init__(self, use_spacy=True):\n self._use_spacy = use_spacy","def configure_stp_instance(self, instance, **kwargs):\n pass","def __init__(self, options):\n # option[0] = true means use all instances to calculate the w, w0.\n # option[0] = false means use SDG to calculate the w, w0.\n self.gradients_type = options[0]\n self.X_train = options[1]\n self.y_train = options[2]\n self.X_test = options[3]\n self.y_test = options[4]\n self.X = options[5]\n self.y = options[6]\n # initial w select zeros\n self.lamda = 0.1\n self.w_result = 0\n self.tim = []\n self.los_plt = []","def test_load_str(self):\n o = \"soap\"\n cls = pytan3.adapters.load(o)\n assert issubclass(cls, pytan3.adapters.Soap)","def __init__(self, mxd, servicename, url, datasources):\n self.name = servicename\n self.url = url\n self.mxd = mxd\n self._dbnames = sorted(datasources.keys())\n self._featureclasses = [y for x in datasources.values() for y in x]\n self._datastructure = datasources","def __init__(self):\n self.swagger_types = {\n 'discovery': 'Discovery',\n 'groups': 'list[str]',\n 'labels': 'object'\n }\n\n self.attribute_map = {\n 'discovery': 'discovery',\n 'groups': 'groups',\n 'labels': 'labels'\n }\n\n self._discovery = None\n self._groups = None\n self._labels = None","def make_instance(scene, features, params, instances, direction,\n focus_measures, classification, weight):\n evaluator = action_feature_evaluator(focus_measures, scene.step_count)\n\n # Randomly select only a subset of instances based on their weight.\n if params.outlierHandling == OutlierHandling.SAMPLING:\n if random.random() <= weight * params.uniformSamplingRate:\n instance = ( [ evaluator(feature) for _, feature in features ], \n classification )\n instances.append(instance)\n elif params.outlierHandling == OutlierHandling.WEIGHTING:\n if random.random() <= params.uniformSamplingRate:\n instance = ( [ evaluator(feature) for _, feature in features ], \n classification, weight )\n instances.append(instance)\n else:\n assert False","def __init__(self, instance_or_wire):\n super(TimeSeries, self).__init__()\n\n self._collection = None\n self._data = None\n\n if isinstance(instance_or_wire, TimeSeries):\n # copy ctor\n # pylint: disable=protected-access\n self._collection = instance_or_wire._collection\n self._data = instance_or_wire._data\n\n elif isinstance(instance_or_wire, dict):\n if 'events' in instance_or_wire:\n # list of events dict(name='events', events=[list, of, events])\n\n self._collection = Collection(instance_or_wire.get('events', []))\n\n meta = copy.copy(instance_or_wire)\n meta.pop('events')\n\n self._data = self.build_metadata(meta)\n\n elif 'collection' in instance_or_wire:\n # collection dict(name='collection', collection=collection_obj)\n\n self._collection = instance_or_wire.get('collection', None)\n\n meta = copy.copy(instance_or_wire)\n meta.pop('collection')\n\n self._data = self.build_metadata(meta)\n\n elif 'columns' in instance_or_wire and 'points' in instance_or_wire:\n # coming from the wire format\n\n event_type = instance_or_wire.get('columns')[0]\n event_fields = instance_or_wire.get('columns')[1:]\n\n events = list()\n\n for i in instance_or_wire.get('points'):\n time = i[0]\n event_values = i[1:]\n data = dict(list(zip(event_fields, event_values)))\n try:\n events.append(self.event_type_map[event_type](time, data))\n except KeyError:\n msg = 'invalid event type {et}'.format(et=event_type)\n raise TimeSeriesException(msg)\n\n self._collection = Collection(events)\n\n meta = copy.copy(instance_or_wire)\n meta.pop('columns')\n meta.pop('points')\n\n self._data = self.build_metadata(meta)\n\n else:\n msg = 'unable to determine dict format'\n raise TimeSeriesException(msg)\n else:\n # unable to determine\n msg = 'arg must be a TimeSeries instance or dict'\n raise TimeSeriesException(msg)\n\n if self._collection.is_chronological() is not True:\n msg = 'Events supplied to TimeSeries constructor must be chronological'\n raise TimeSeriesException(msg)","def __init__(self, py_dict=None):\n super(EventThresholdsSchema, self).__init__()\n self.set_data_type(\"xml\")\n self.cpu = CpuSchema()\n self.memory = MemorySchema()\n self.connectionsPerSecond = CpsSchema()\n\n\n if py_dict is not None:\n self.get_object_from_py_dict(py_dict)","def restore_object(self, attrs, instance=None):\n if instance:\n # update existing instance\n instance.name = attrs.get('name', instance.name)\n instance.price = attrs.get('price', instance.price)\n\n # create new instance\n return Service(**attrs)","def __init__(self, py_dict=None):\n super(BGPNeighbourSchema, self).__init__()\n self.set_data_type(\"xml\")\n self.bgpFilters = None\n self.holdDownTimer = None\n self.weight = None\n self.remoteAS = None\n self.protocolAddress = None\n self.forwardingAddress = None\n self.password = None\n self.ipAddress = None\n self.keepAliveTimer = None\n\n if py_dict is not None:\n self.get_object_from_py_dict(py_dict)","def _create_dummy_wsdl(self, xsd):\n\n if (path.exists(xsd)):\n try:\n with open(xsd, 'r') as f:\n tns = search(r'targetNamespace=\"(.*)\"', f.read()).group(1)\n if ('\"' in tns):\n tns = tns[: tns.index('\"')]\n\n filename = xsd.split('/')[-1]\n wsdl = path.abspath(xsd)[:-3] + 'wsdl'\n\n with open(wsdl, 'w') as f:\n f.write(wsdl_tmpl.format(tns, tns, tns, filename))\n\n return wsdl\n except AttributeError as ex:\n raise ValueError('File {0} is not valid XSD'.format(xsd))\n\n else:\n raise ValueError('File {0} not found'.format(xsd))","def startInstance(self, name=None,\n location=None,\n familyName=None,\n styleName=None,\n fileName=None,\n postScriptFontName=None,\n styleMapFamilyName=None,\n styleMapStyleName=None,\n\n ):\n if self.currentInstance is not None:\n # We still have the previous one open\n self.endInstance()\n instanceElement = ET.Element('instance')\n if name is not None:\n instanceElement.attrib['name'] = name\n if location is not None:\n locationElement = self._makeLocationElement(location)\n instanceElement.append(locationElement)\n if familyName is not None:\n instanceElement.attrib['familyname'] = familyName\n if styleName is not None:\n instanceElement.attrib['stylename'] = styleName\n if fileName is not None:\n instanceElement.attrib['filename'] = self._posixPathRelativeToDocument(fileName)\n if postScriptFontName is not None:\n instanceElement.attrib['postscriptfontname'] = postScriptFontName\n if styleMapFamilyName is not None:\n instanceElement.attrib['stylemapfamilyname'] = styleMapFamilyName\n if styleMapStyleName is not None:\n instanceElement.attrib['stylemapstylename'] = styleMapStyleName\n\n self.currentInstance = instanceElement","def test_create(self):\n from supvisors.statistics import StatisticsInstance\n instance = StatisticsInstance(17, 10)\n # check attributes\n self.assertEqual(3, instance.period)\n self.assertEqual(10, instance.depth)\n self.assertEqual(-1, instance.counter)\n self.assertIsNone(instance.ref_stats)\n self.assertIs(list, type(instance.cpu))\n self.assertFalse(instance.cpu)\n self.assertIs(list, type(instance.mem))\n self.assertFalse(instance.mem)\n self.assertIs(dict, type(instance.io))\n self.assertFalse(instance.io)\n self.assertIs(dict, type(instance.proc))\n self.assertFalse(instance.proc)","def _fill_instance_child(self, xmldoc, element_name, return_type):\n xmlelements = self._get_child_nodes(xmldoc, self._get_serialization_name(element_name))\n\n if not xmlelements:\n return None\n\n return_obj = return_type()\n self._fill_data_to_return_object(xmlelements[0], return_obj)\n\n return return_obj","def instantiate(self, features=()):\n\n if self._cls and not self._tool:\n tool = self._cls.instance(features)\n return getattr(tool, self.name)\n else:\n return self","def createService(data):\n return Service(data).create()","def __init__(self, name=None, description=None, address_1=None, address_2=None, city=None, county=None, postcode=None, country_id=None, currency_id=None, business_email=None, business_phone=None, vat_number=None, registration_number=None, latitude=None, longitude=None, timezone=None, contact=None, website=None):\n self.swagger_types = {\n 'name': 'str',\n 'description': 'str',\n 'address_1': 'str',\n 'address_2': 'str',\n 'city': 'str',\n 'county': 'str',\n 'postcode': 'str',\n 'country_id': 'int',\n 'currency_id': 'int',\n 'business_email': 'str',\n 'business_phone': 'str',\n 'vat_number': 'str',\n 'registration_number': 'str',\n 'latitude': 'float',\n 'longitude': 'float',\n 'timezone': 'str',\n 'contact': 'str',\n 'website': 'str'\n }\n\n self.attribute_map = {\n 'name': 'name',\n 'description': 'description',\n 'address_1': 'address_1',\n 'address_2': 'address_2',\n 'city': 'city',\n 'county': 'county',\n 'postcode': 'postcode',\n 'country_id': 'country_id',\n 'currency_id': 'currency_id',\n 'business_email': 'business_email',\n 'business_phone': 'business_phone',\n 'vat_number': 'vat_number',\n 'registration_number': 'registration_number',\n 'latitude': 'latitude',\n 'longitude': 'longitude',\n 'timezone': 'timezone',\n 'contact': 'contact',\n 'website': 'website'\n }\n\n self._name = name\n self._description = description\n self._address_1 = address_1\n self._address_2 = address_2\n self._city = city\n self._county = county\n self._postcode = postcode\n self._country_id = country_id\n self._currency_id = currency_id\n self._business_email = business_email\n self._business_phone = business_phone\n self._vat_number = vat_number\n self._registration_number = registration_number\n self._latitude = latitude\n self._longitude = longitude\n self._timezone = timezone\n self._contact = contact\n self._website = website","def create_custom():\n # Extract initialisation parameters\n alpha = request.args.get('alpha')\n alpha = float(alpha)\n generations = request.args.get('generations')\n generations = int(generations)\n beta = request.args.get('beta')\n beta = float(beta)\n pec = request.args.get('pec')\n pec = float(pec)\n q = request.args.get('q')\n q = float(q)\n\n # Extract the custom coordinates and create a list of nodes\n coords = request.args.get('custom_coords')\n coords = str(coords)\n nodes = custom_nodes(coords)\n\n # Initialise instance\n i = Instance(nodes, alpha, beta, pec, q)\n\n return jsonify(nodes=i.nodes, alpha=i.alpha, beta=i.beta, decay=i.decay,\n min_pheromone=i.min_pheromone, q=i.q,\n local_deposit=i.local_deposit, distances=i.distances,\n pheromones=i.pheromones, ants=i.ants, shortest_path=i.shortest_path,\n min_distance=i.min_distance, message=\"Instance Initialised\")","def __init__(self, **kwargs):\n source = kwargs\n if 'xml_element' in kwargs:\n source = kwargs.get('xml_element')\n validate_xml_element(source, self.ELEMENT_TAG)\n\n self.tag = source.get('tag', '')\n\n # Some versions of Stop have additional attributes. Only add them to the class if they exist.\n title = source.get('title')\n if title:\n self.title = title\n\n short_title = source.get('shortTitle')\n if short_title:\n self.short_title = short_title\n\n lat = source.get('lat')\n if lat:\n self.lat = lat\n\n lon = source.get('lon')\n if lon:\n self.lon = lon","def __init__(self, file_name,\n word_vocab,\n max_sent_len,\n num_class):\n self.examples = examples = ParseExample.load_data(file_name)\n\n instance_id_list = []\n warrant0_list = []\n warrant1_list = []\n correct_label_w0_or_w1_list = []\n reason_list = []\n claim_list = []\n debate_meta_data_list = []\n\n warrant0_len = []\n warrant1_len = []\n reason_len = []\n claim_len = []\n debate_meta_data_len = []\n\n for example in examples:\n warrant0, warrant1, reason, claim, debate_meta_data, negclaim = example.get_six(type=WORD_TYPE)\n instance_id = example.get_id()\n correct_label_w0_or_w1 = example.get_label()\n\n # convert to the ids\n warrant0 = data_utils.sent_to_index(warrant0, word_vocab)\n warrant1 = data_utils.sent_to_index(warrant1, word_vocab)\n reason = data_utils.sent_to_index(reason, word_vocab)\n claim = data_utils.sent_to_index(claim, word_vocab)\n debate_meta_data = data_utils.sent_to_index(debate_meta_data, word_vocab)\n correct_label_w0_or_w1 = data_utils.onehot_vectorize(correct_label_w0_or_w1, num_class)\n\n warrant0_len.append(min(len(warrant0), max_sent_len))\n warrant1_len.append(min(len(warrant1), max_sent_len))\n reason_len.append(min(len(reason), max_sent_len))\n claim_len.append(min(len(claim), max_sent_len))\n debate_meta_data_len.append(min(len(debate_meta_data), max_sent_len))\n\n # add to the result\n instance_id_list.append(instance_id)\n warrant0_list.append(warrant0)\n warrant1_list.append(warrant1)\n correct_label_w0_or_w1_list.append(correct_label_w0_or_w1)\n reason_list.append(reason)\n claim_list.append(claim)\n debate_meta_data_list.append(debate_meta_data)\n\n warrant0_list = data_utils.pad_2d_matrix(warrant0_list, max_sent_len)\n warrant1_list = data_utils.pad_2d_matrix(warrant1_list, max_sent_len)\n reason_list = data_utils.pad_2d_matrix(reason_list, max_sent_len)\n claim_list = data_utils.pad_2d_matrix(claim_list, max_sent_len)\n debate_meta_data_list = data_utils.pad_2d_matrix(debate_meta_data_list, max_sent_len)\n\n # text\n self.instance_id_list = np.array(instance_id_list)\n # float\n self.correct_label_w0_or_w1_list = np.array(correct_label_w0_or_w1_list, dtype=np.float32)\n # int\n self.warrant0_list = np.array(warrant0_list, dtype=np.int32)\n self.warrant1_list = np.array(warrant1_list, dtype=np.int32)\n self.reason_list = np.array(reason_list, dtype=np.int32)\n self.claim_list = np.array(claim_list, dtype=np.int32)\n self.debate_meta_data_list = np.array(debate_meta_data_list, dtype=np.int32)\n\n self.warrant0_len = np.array(warrant0_len, dtype=np.int32)\n self.warrant1_len = np.array(warrant1_len, dtype=np.int32)\n self.reason_len = np.array(reason_len, dtype=np.int32)\n self.claim_len = np.array(claim_len, dtype=np.int32)\n self.debate_meta_data_len = np.array(debate_meta_data_len, dtype=np.int32)\n\n self.do_id = word_vocab['do']\n\n # obtain the diff part\n diff_warrant0_list = []\n diff_warrant1_list = []\n diff_claim_list = []\n diff_warrant0_len_list = []\n diff_warrant1_len_list = []\n diff_claim_len_list = []\n id = 0\n for example in examples:\n warrant0, warrant1, reason, claim, debate_meta_data, negclaim = example.get_six(type=WORD_TYPE)\n la, ra, lb, rb = diffsents(warrant0, warrant1)\n diff_warrant0 = warrant0[la: ra + 1]\n diff_warrant1 = warrant1[lb: rb + 1]\n la, ra, _, _ = diffsents(claim, negclaim)\n diff_claim = claim[la: ra+1]\n # print(warrant0, warrant1, diff_warrant0, diff_warrant1)\n # print(claim, negclaim, diff_claim)\n # id += 1\n # if id == 10:\n # exit(1)\n\n # convert to the ids\n diff_warrant0 = data_utils.sent_to_index(diff_warrant0, word_vocab)\n diff_warrant1 = data_utils.sent_to_index(diff_warrant1, word_vocab)\n diff_claim = data_utils.sent_to_index(diff_claim, word_vocab)\n\n diff_warrant0_list.append(diff_warrant0)\n diff_warrant1_list.append(diff_warrant1)\n diff_claim_list.append(diff_claim)\n\n diff_warrant0_len_list.append(min(len(diff_warrant0), config.max_diff_len))\n diff_warrant1_len_list.append(min(len(diff_warrant1), config.max_diff_len))\n diff_claim_len_list.append(min(len(diff_claim), config.max_diff_len))\n\n diff_warrant0_list = data_utils.pad_2d_matrix(diff_warrant0_list, config.max_diff_len)\n diff_warrant1_list = data_utils.pad_2d_matrix(diff_warrant1_list, config.max_diff_len)\n diff_claim_list = data_utils.pad_2d_matrix(diff_claim_list, config.max_diff_len)\n\n # int\n self.diff_warrant0_list = np.array(diff_warrant0_list, dtype=np.int32)\n self.diff_warrant1_list = np.array(diff_warrant1_list, dtype=np.int32)\n self.diff_claim_list = np.array(diff_claim_list, dtype=np.int32)\n\n self.diff_warrant0_len = np.array(diff_warrant0_len_list, dtype=np.int32)\n self.diff_warrant1_len = np.array(diff_warrant1_len_list, dtype=np.int32)\n self.diff_claim_len = np.array(diff_claim_len_list, dtype=np.int32)","def learn(instance: machine_learning.StationMachineLearning):\n instance.learn()","def __init__(self, use_existing_vocab: bool = True):\n\n self._db_connection = postgresql.DatabaseConnection()\n self._use_existing_vocab = use_existing_vocab","def create_stp_instance(self, instance, priority):\n pass","def from_xml(cls, xml_data, system, id_generator):\r\n\r\n xml_object = etree.fromstring(xml_data)\r\n system.error_tracker('WARNING: the <{tag}> tag is deprecated. '\r\n 'Instead, use . '\r\n .format(tag=xml_object.tag))\r\n\r\n tag = xml_object.tag\r\n xml_object.tag = 'customtag'\r\n xml_object.attrib['impl'] = tag\r\n\r\n return system.process_xml(etree.tostring(xml_object))","def build_from_instance(self, instanceDict={}):\n if not instanceDict.keys():\n print \"Instance's dictionary not provided. Please provide a dictionary that contains instance's information.\"\n return\n\n from node import Node\n from edge import Edge\n\n self.__instance_dictionary = instanceDict\n self.__name = instanceDict[\"header\"][\"NAME\"] # name of the graph\n self.__nodes = [] # Array of nodes\n self.__num_nodes = 0 # Number of nodes\n self.__edges = [] # Array of edges\n self.__num_edges = 0 # Number of edges\n self.__adjacency_matrix = [] # initialize an empty adjacency matrix\n self.__adjacency_matrix_dictionary = {} # initialize an empty double dictionary adjacency object\n\n # add nodes to the graph\n for curNodeVal in xrange(0, instanceDict[\"header\"][\"DIMENSION\"]):\n new_node = Node(curNodeVal, instanceDict[\"nodes\"][curNodeVal]) # create a new node instance\n self.add_node(new_node) # add node to the graph\n\n # add edges to graph\n for tupleEdge in instanceDict[\"edges\"]:\n node_a_id = tupleEdge[0]\n node_b_id = tupleEdge[1]\n edge_weight = tupleEdge[2]\n\n #if edge_weight > 0:\n if node_a_id != node_b_id:\n new_edge = Edge(self.__nodes[node_a_id], self.__nodes[node_b_id], edge_weight) # create edge\n self.add_edge(new_edge)","def _readSingleInstanceElement(\n self,\n instanceElement,\n makeGlyphs=True,\n makeKerning=True,\n makeInfo=True,\n bendLocations=False,\n ):\n # get the data from the instanceElement itself\n filename = instanceElement.attrib.get('filename')\n\n instancePath = os.path.join(os.path.dirname(self.path), filename)\n self.reportProgress(\"generate\", 'start', instancePath)\n if self.verbose and self.logger:\n self.logger.info(\"\\tGenerating instance %s\", os.path.basename(instancePath))\n filenameTokenForResults = os.path.basename(filename)\n\n instanceObject = self._instanceWriterClass(\n instancePath,\n ufoVersion=self.ufoVersion,\n roundGeometry=self.roundGeometry,\n axes = self.axes,\n verbose=self.verbose,\n logger=self.logger,\n bendLocations=bendLocations,\n )\n self.results[filenameTokenForResults] = instancePath\n\n # set the masters\n instanceObject.setSources(self.sources)\n self.unicodeMap = instanceObject.makeUnicodeMapFromSources()\n instanceObject.setMuted(self.muted)\n familyname = instanceElement.attrib.get('familyname')\n if familyname is not None:\n instanceObject.setFamilyName(familyname)\n stylename = instanceElement.attrib.get('stylename')\n if stylename is not None:\n instanceObject.setStyleName(stylename)\n postScriptFontName = instanceElement.attrib.get('postscriptfontname')\n if postScriptFontName is not None:\n instanceObject.setPostScriptFontName(postScriptFontName)\n styleMapFamilyName = instanceElement.attrib.get('stylemapfamilyname')\n if styleMapFamilyName is not None:\n instanceObject.setStyleMapFamilyName(styleMapFamilyName)\n styleMapStyleName = instanceElement.attrib.get('stylemapstylename')\n if styleMapStyleName is not None:\n instanceObject.setStyleMapStyleName(styleMapStyleName)\n\n # location\n instanceLocation = self.locationFromElement(instanceElement)\n\n if instanceLocation is not None:\n instanceObject.setLocation(instanceLocation)\n\n if makeGlyphs:\n\n # step 1: generate all glyphs we have mutators for.\n names = instanceObject.getAvailableGlyphnames()\n for n in names:\n unicodes = self.unicodeMap.get(n, None)\n try:\n instanceObject.addGlyph(n, unicodes)\n except AssertionError:\n if self.verbose and self.logger:\n self.logger.info(\"Problem making glyph %s, skipping.\", n)\n # step 2: generate all the glyphs that have special definitions.\n for glyphElement in instanceElement.findall('.glyphs/glyph'):\n self.readGlyphElement(glyphElement, instanceObject)\n\n # read the kerning\n if makeKerning:\n for kerningElement in instanceElement.findall('.kerning'):\n self.readKerningElement(kerningElement, instanceObject)\n break\n\n # read the fontinfo\n if makeInfo:\n for infoElement in instanceElement.findall('.info'):\n self.readInfoElement(infoElement, instanceObject)\n\n # copy the features\n if self.featuresSource is not None:\n instanceObject.copyFeatures(self.featuresSource)\n\n # copy the groups\n if self.groupsSource is not None:\n if self.groupsSource in self.sources:\n groupSourceObject, loc = self.sources[self.groupsSource]\n # copy the groups from the designated source to the new instance\n # note: setGroups will filter the group members\n # only glyphs present in the font will be added to the group.\n # Depending on the ufoversion we might or might not expect the kerningGroupConversionRenameMaps attribute.\n if hasattr(groupSourceObject, \"kerningGroupConversionRenameMaps\"):\n renameMap = groupSourceObject.kerningGroupConversionRenameMaps\n else:\n renameMap = {}\n instanceObject.setGroups(groupSourceObject.groups, kerningGroupConversionRenameMaps=renameMap)\n\n # lib items\n if self.libSource is not None:\n if self.libSource in self.sources:\n libSourceObject, loc = self.sources[self.libSource]\n instanceObject.setLib(libSourceObject.lib)\n\n # save the instance. Done.\n success, report = instanceObject.save()\n if not success and self.logger:\n # report problems other than validation errors and failed glyphs\n self.logger.info(\"%s:\\nErrors generating: %s\", filename, report)\n\n # report failed glyphs\n failed = instanceObject.getFailed()\n if failed:\n failed.sort()\n msg = \"%s:\\nErrors calculating %s glyphs: \\n%s\"%(filename, len(failed),\"\\t\"+\"\\n\\t\".join(failed))\n self.reportProgress('error', 'glyphs', msg)\n if self.verbose and self.logger:\n self.logger.info(msg)\n\n # report missing unicodes\n missing = instanceObject.getMissingUnicodes()\n if missing:\n missing.sort()\n msg = \"%s:\\nPossibly missing unicodes for %s glyphs: \\n%s\"%(filename, len(missing),\"\\t\"+\"\\n\\t\".join(missing))\n self.reportProgress('error', 'unicodes', msg)\n\n # store\n self.instances[postScriptFontName] = instanceObject\n self.reportProgress(\"generate\", 'stop', filenameTokenForResults)","def get_serialization_instance(cls, value):\n\n # if the instance is a list, convert it to a cls instance.\n # this is only useful when deserializing method arguments for a client\n # request which is the only time when the member order is not arbitrary\n # (as the members are declared and passed around as sequences of\n # arguments, unlike dictionaries in a regular class definition).\n if isinstance(value, list) or isinstance(value, tuple):\n assert len(value) <= len(cls._type_info)\n\n cls_orig = cls\n if cls.__orig__ is not None:\n cls_orig = cls.__orig__\n inst = cls_orig()\n\n keys = cls._type_info.keys()\n for i in range(len(value)):\n setattr(inst, keys[i], value[i])\n\n elif isinstance(value, dict):\n inst = cls()\n\n for k in cls._type_info:\n setattr(inst, k, value.get(k, None))\n\n else:\n inst = value\n\n return inst","def __init__(self, name=None, debug_mode=False, features=None, ui=None, is_default=False, created=None, modified=None, id=None, team_id=None, team=None, portals=None, product_groups=None, product_types=None, product_sizes=None, product_size_materials=None, product_size_materials_rel=None):\n self.swagger_types = {\n 'name': 'str',\n 'debug_mode': 'bool',\n 'features': 'object',\n 'ui': 'object',\n 'is_default': 'bool',\n 'created': 'datetime',\n 'modified': 'datetime',\n 'id': 'str',\n 'team_id': 'str',\n 'team': 'Team',\n 'portals': 'list[Portal]',\n 'product_groups': 'list[ProductGroup]',\n 'product_types': 'list[ProductType]',\n 'product_sizes': 'list[ProductSize]',\n 'product_size_materials': 'list[ProductSizeMaterial]',\n 'product_size_materials_rel': 'list[TeamBuilderConfigProductSizeMaterial]'\n }\n\n self.attribute_map = {\n 'name': 'name',\n 'debug_mode': 'debugMode',\n 'features': 'features',\n 'ui': 'ui',\n 'is_default': 'isDefault',\n 'created': 'created',\n 'modified': 'modified',\n 'id': 'id',\n 'team_id': 'teamId',\n 'team': 'team',\n 'portals': 'portals',\n 'product_groups': 'productGroups',\n 'product_types': 'productTypes',\n 'product_sizes': 'productSizes',\n 'product_size_materials': 'productSizeMaterials',\n 'product_size_materials_rel': 'productSizeMaterialsRel'\n }\n\n self._name = name\n self._debug_mode = debug_mode\n self._features = features\n self._ui = ui\n self._is_default = is_default\n self._created = created\n self._modified = modified\n self._id = id\n self._team_id = team_id\n self._team = team\n self._portals = portals\n self._product_groups = product_groups\n self._product_types = product_types\n self._product_sizes = product_sizes\n self._product_size_materials = product_size_materials\n self._product_size_materials_rel = product_size_materials_rel","def create(cls, xml):\n raise Exception('Not Implemented Yet')","def __init__(self, *args, **kwargs):\r\n super(OWS, self).__init__(*args, **kwargs)\r\n\r\n self.query = {\"VERSION\": \"1.0.0\", \"REQUEST\": \"GetCapabilities\"}\r\n # Amended with \"SERVICE\" parameter by subclasses\r\n\r\n # If service or version parameters are left in query string, it can lead to a protocol error and false negative\r\n self.service_url = re.sub(r\"(?i)(version|service|request)=.*?(&|$)\", \"\", self.service_url)\r\n\r\n self.layer = self.layer.lower() if self.layer else None\r\n self.layer_elements = None","def create_foundation_sdk_instance():\n instance = LockedInstance(\n lock=threading.Lock(),\n instance=SDK(**(request.get_json() or {})),\n module=None,\n entity=SDK_ENTITY_NAME,\n uuid=str(uuid.uuid4().hex),\n created_at=datetime.datetime.utcnow(),\n )\n STORE[instance.uuid] = instance\n response = app.response_class(\n response=json.dumps(serialise_instance(instance)),\n status=201,\n mimetype='application/json'\n )\n return response","def from_xml(cls, xml_data, system, id_generator):\r\n raise NotImplementedError('Modules must implement from_xml to be parsable from xml')","def create_service_instance(self, serviceManufacturer, serviceType) -> Union[UpnpServiceProxy, None]:\n serviceInst = None\n if serviceType is not None:\n extkey = generate_extension_key(serviceManufacturer, serviceType)\n if extkey in self._service_registry:\n serviceClass = self._service_registry[extkey]\n serviceInst = serviceClass()\n return serviceInst","def __init__(self, **kwargs):\n with KWArgs(kwargs) as k:\n metadata = k.optional(\"metadata\")\n\n self._ax = ca.boolean()\n self.metadata = metadata"],"string":"[\n \"def _prepare_wsdl_objects(self):\\r\\n # This holds some optional options for the request..\\r\\n self.AddressValidationOptions = self.client.factory.create('AddressValidationOptions')\\r\\n \\r\\n # This is good to review if you'd like to see what the data structure\\r\\n # looks like.\\r\\n self.logger.debug(self.AddressValidationOptions)\",\n \"def create_wsdl_object_of_type(self, type_name):\\r\\n return self.client.factory.create(type_name)\",\n \"def __prepare_wsdl_objects(self):\\r\\n pass\",\n \"def get_instance(self, instance_type, name, subdir=\\\"\\\"):\\r\\n\\r\\n def read_data(data_syntax, file_name, sub_dir=\\\"\\\"):\\r\\n alns_data = pickle.load(open(join(self.base_path, data_syntax, \\\"data\\\", sub_dir, file_name), 'rb'))\\r\\n return alns_data\\r\\n\\r\\n if instance_type == \\\"simple\\\":\\r\\n nr_vehicles = 2\\r\\n nr_nodes = 4\\r\\n nr_customers = 3\\r\\n load_bucket_size = 10\\r\\n demand = [110, 100, 150]\\r\\n service_times = [10, 10, 10]\\r\\n start_window = [0, 0, 0]\\r\\n end_window = [100, 100, 100]\\r\\n\\r\\n distance_matrix = [[0, 3, 2, 3], [3, 0, 1.75, 4], [2, 1.75, 0, 2.5], [3, 4, 2.5, 0]]\\r\\n elevation_matrix = [[0.1, 0.2, 0, 0], [0, 0, 0.3, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\\r\\n\\r\\n return ALNSData(nr_veh=nr_vehicles,\\r\\n nr_nodes=nr_nodes,\\r\\n nr_customers=nr_customers,\\r\\n demand=demand,\\r\\n service_times=service_times,\\r\\n start_window=start_window,\\r\\n end_window=end_window,\\r\\n elevation_m=elevation_matrix,\\r\\n distance_m=distance_matrix,\\r\\n load_bucket_size=load_bucket_size)\\r\\n\\r\\n try:\\r\\n return read_data(self.code_lookup[instance_type], file_name=name, sub_dir=subdir)\\r\\n except KeyError:\\r\\n raise ValueError(\\\"instance_type is not known: Valid inputs are: pirmin, solomon, cordeau, homberger\\\")\",\n \"def __init__(__self__, *,\\n wsdl_endpoint_name: Optional[pulumi.Input[str]] = None,\\n wsdl_service_name: Optional[pulumi.Input[str]] = None):\\n if wsdl_endpoint_name is not None:\\n pulumi.set(__self__, \\\"wsdl_endpoint_name\\\", wsdl_endpoint_name)\\n if wsdl_service_name is not None:\\n pulumi.set(__self__, \\\"wsdl_service_name\\\", wsdl_service_name)\",\n \"def get_instance_from_words(data):\\n inst = Dataset.get_instance_template()\\n inst[\\\"words\\\"] = data\\n return inst\",\n \"def __init__(self, py_dict=None):\\n super(RuntimeNicInfoSchema, self).__init__()\\n self.set_data_type('xml')\\n self.index = None\\n self.label = None\\n self.network = NetworkSchema()\\n\\n if py_dict is not None:\\n self.get_object_from_py_dict(py_dict)\",\n \"def convertInstanceData(self, builder, typeName, data):\\n\\t\\tif typeName not in self.instanceDataTypeMap:\\n\\t\\t\\traise Exception('Instance data type \\\"' + typeName + '\\\" hasn\\\\'t been registered.')\\n\\n\\t\\tconvertedData = self.instanceDataTypeMap[typeName](self, data)\\n\\n\\t\\ttypeNameOffset = builder.CreateString(typeName)\\n\\t\\tdataOffset = builder.CreateByteVector(convertedData)\\n\\n\\t\\tObjectData.Start(builder)\\n\\t\\tObjectData.AddType(builder, typeNameOffset)\\n\\t\\tObjectData.AddData(builder, dataOffset)\\n\\t\\treturn ObjectData.End(builder)\",\n \"def _prepare_wsdl_objects(self):\\r\\n self.DeletionControlType = self.client.factory.create('DeletionControlType')\\r\\n self.TrackingId = self.client.factory.create('TrackingId')\\r\\n self.TrackingId.TrackingIdType = self.client.factory.create('TrackingIdType')\",\n \"def __init__(self, py_dict=None):\\n super(ServiceManagerSchema, self).__init__()\\n self.set_data_type('xml')\\n self.name = None\\n self.description = None\\n self.revision = None\\n self.objectTypeName = None\\n self.vendorName = None\\n self.vendorId = None\\n self.thumbprint = None\\n self.login = None\\n self.password = None\\n self.verifyPassword = None\\n self.url = None\\n self.restUrl = None\\n self.status = None\\n\\n if py_dict is not None:\\n self.get_object_from_py_dict(py_dict)\",\n \"def test_create_instance(self):\\n engine = Engine(self.config_file, self.api_token)\\n\\n assert isinstance(engine, Engine) is True\\n assert isinstance(engine.backend, Backend) is True\\n assert isinstance(engine.backend, BossBackend) is True\\n assert isinstance(engine.validator, Validator) is True\\n assert isinstance(engine.validator, BossValidatorV02) is True\\n assert isinstance(engine.config, Configuration) is True\\n\\n # Schema loaded\\n assert isinstance(engine.config.schema, dict) is True\\n assert engine.config.schema[\\\"type\\\"] == \\\"object\\\"\",\n \"def __init__(self, config_obj, wsdl_name, *args, **kwargs):\\r\\n self.logger = logging.getLogger('fedex')\\r\\n \\\"\\\"\\\"@ivar: Python logger instance with name 'fedex'.\\\"\\\"\\\"\\r\\n self.config_obj = config_obj\\r\\n \\\"\\\"\\\"@ivar: The FedexConfig object to pull auth info from.\\\"\\\"\\\"\\r\\n\\r\\n # If the config object is set to use the test server, point\\r\\n # suds at the test server WSDL directory.\\r\\n if config_obj.use_test_server:\\r\\n self.logger.info(\\\"Using test server.\\\")\\r\\n self.wsdl_path = os.path.join(config_obj.wsdl_path,\\r\\n 'test_server_wsdl', wsdl_name)\\r\\n else:\\r\\n self.logger.info(\\\"Using production server.\\\")\\r\\n self.wsdl_path = os.path.join(config_obj.wsdl_path, wsdl_name)\\r\\n\\r\\n self.client = Client('file:///%s' % self.wsdl_path.lstrip('/'))\\r\\n\\r\\n #print self.client\\r\\n\\r\\n self.VersionId = None\\r\\n \\\"\\\"\\\"@ivar: Holds details on the version numbers of the WSDL.\\\"\\\"\\\"\\r\\n self.WebAuthenticationDetail = None\\r\\n \\\"\\\"\\\"@ivar: WSDL object that holds authentication info.\\\"\\\"\\\"\\r\\n self.ClientDetail = None\\r\\n \\\"\\\"\\\"@ivar: WSDL object that holds client account details.\\\"\\\"\\\"\\r\\n self.response = None\\r\\n \\\"\\\"\\\"@ivar: The response from Fedex. You will want to pick what you\\r\\n want out here here. This object does have a __str__() method,\\r\\n you'll want to print or log it to see what possible values\\r\\n you can pull.\\\"\\\"\\\"\\r\\n self.TransactionDetail = None\\r\\n \\\"\\\"\\\"@ivar: Holds customer-specified transaction IDs.\\\"\\\"\\\"\\r\\n\\r\\n self.__set_web_authentication_detail()\\r\\n self.__set_client_detail()\\r\\n self.__set_version_id()\\r\\n self.__set_transaction_detail(*args, **kwargs)\\r\\n self._prepare_wsdl_objects()\",\n \"def __init__(self, use=True):\\n self.use = use\",\n \"def _create_soap_object(self, name):\\n return self.client.factory.create(name)\",\n \"def __init__(self, enable_gateway=False, topology_name=None, topologies=None, exposed_services=None, token_cert=None, gateway_type=None, sso_type=None):\\n\\n self._enable_gateway = None\\n self._topology_name = None\\n self._topologies = None\\n self._exposed_services = None\\n self._token_cert = None\\n self._gateway_type = None\\n self._sso_type = None\\n\\n if enable_gateway is not None:\\n self.enable_gateway = enable_gateway\\n if topology_name is not None:\\n self.topology_name = topology_name\\n if topologies is not None:\\n self.topologies = topologies\\n if exposed_services is not None:\\n self.exposed_services = exposed_services\\n if token_cert is not None:\\n self.token_cert = token_cert\\n if gateway_type is not None:\\n self.gateway_type = gateway_type\\n if sso_type is not None:\\n self.sso_type = sso_type\",\n \"def given_an_instance() -> machine_learning.StationMachineLearning:\\n # super weird bug? with pytest_bdd that hooked into isoformat on the coordinate and points fields.\\n # tried forever to figure out why - and gave up in the end. removed coordinate and point from\\n # feature file and just loading it in here.\\n coordinate = _load_json_file(__file__, 'coordinate.json')\\n points = _load_json_file(__file__, 'points.json')\\n return machine_learning.StationMachineLearning(\\n session=None,\\n model=PredictionModel(id=1),\\n grid=PredictionModelGridSubset(id=1),\\n points=points,\\n target_coordinate=coordinate,\\n station_code=None,\\n max_learn_date=datetime.now())\",\n \"def validate_is_instance(var: Any,\\n var_name: str,\\n instance_type: Any,\\n class_name: Optional[str] = None,\\n log_metadata_validation_failures: bool = True) -> None:\\n if var is None:\\n return\\n splits = str(instance_type).split(\\\" 1:\\n print_type = splits[1]\\n else:\\n print_type = splits[0]\\n if log_metadata_validation_failures:\\n if class_name is None:\\n logging.debug(\\n \\\"XAI Validation :: Metadata: Variable `%s` should be of type `%s`\\\",\\n var_name, print_type)\\n else:\\n logging.debug(\\n \\\"XAI Validation :: Metadata: [%s] Variable `%s` should be of type \\\"\\n \\\"`%s`\\\", class_name, var_name, print_type)\\n if not isinstance(var, instance_type):\\n raise TypeError(\\\"{} must be of type {}. Got {}\\\".format(\\n var_name, str(instance_type), str(type(var))))\",\n \"def __init__(self, data):\\n self.jssp_instance_data = data\",\n \"def load_instance(self, instance_path, input_shapes):\\n metadata = load_json(os.path.join(instance_path, 'instance.meta'))\\n self.log('load metadata')\\n\\n instance_class_name = metadata[MODEL_METADATA_KEY_INSTANCE_CLASS_NAME]\\n instance_source_path = metadata[MODEL_METADATA_KEY_INSTANCE_SOURCE_PATH]\\n model = import_class_from_module_path(instance_source_path, instance_class_name)\\n self.log('instance source code load')\\n\\n self.instance = model(metadata[MODEL_METADATA_KEY_INSTANCE_PATH])\\n self.instance.load_model(metadata, input_shapes)\\n self.log('load instance')\\n\\n instance_id = metadata[MODEL_METADATA_KEY_INSTANCE_ID]\\n self.log('load instance id : %s' % instance_id)\",\n \"def _prepare_wsdl_objects(self):\\r\\n self.TrackPackageIdentifier = self.client.factory.create('TrackPackageIdentifier')\\r\\n # Default to tracking number.\\r\\n self.TrackPackageIdentifier.Type = 'TRACKING_NUMBER_OR_DOORTAG'\",\n \"def __init__(self, api_use=False):\\n self.api_use = api_use\",\n \"def from_url(cls, wsdl_path):\\n return cls(safe_parse_url(wsdl_path))\",\n \"def create_instance(c_instance):\\n\\treturn 0\",\n \"def __init__(self, services, tns):\\r\\n\\r\\n return super(DjangoSoapApp, self).__init__(Application(services, tns))\",\n \"def __init__(self, py_dict=None):\\n super(EdgeNATRulesSchema, self).__init__()\\n self.set_data_type('xml')\\n self.natRule = EdgeNATRuleSchema()\\n\\n if py_dict is not None:\\n self.get_object_from_py_dict(py_dict)\",\n \"def _prepare_wsdl_objects(self):\\r\\n\\r\\n\\t# Default behavior is to not request transit information\\r\\n\\tself.ReturnTransitAndCommit = False\\r\\n\\r\\n # This is the primary data structure for processShipment requests.\\r\\n self.RequestedShipment = self.client.factory.create('RequestedShipment')\\r\\n self.RequestedShipment.ShipTimestamp = datetime.now()\\r\\n \\r\\n TotalWeight = self.client.factory.create('Weight')\\r\\n # Start at nothing.\\r\\n TotalWeight.Value = 0.0\\r\\n # Default to pounds.\\r\\n TotalWeight.Units = 'LB'\\r\\n # This is the total weight of the entire shipment. Shipments may\\r\\n # contain more than one package.\\r\\n self.RequestedShipment.TotalWeight = TotalWeight\\r\\n \\r\\n # This is the top level data structure for Shipper information.\\r\\n ShipperParty = self.client.factory.create('Party')\\r\\n ShipperParty.Address = self.client.factory.create('Address')\\r\\n ShipperParty.Contact = self.client.factory.create('Contact')\\r\\n \\r\\n # Link the ShipperParty to our master data structure.\\r\\n self.RequestedShipment.Shipper = ShipperParty\\r\\n\\r\\n # This is the top level data structure for Recipient information.\\r\\n RecipientParty = self.client.factory.create('Party')\\r\\n RecipientParty.Contact = self.client.factory.create('Contact')\\r\\n RecipientParty.Address = self.client.factory.create('Address')\\r\\n \\r\\n # Link the RecipientParty object to our master data structure.\\r\\n self.RequestedShipment.Recipient = RecipientParty\\r\\n \\r\\n Payor = self.client.factory.create('Payor')\\r\\n # Grab the account number from the FedexConfig object by default.\\r\\n Payor.AccountNumber = self._config_obj.account_number\\r\\n # Assume US.\\r\\n Payor.CountryCode = 'US'\\r\\n \\r\\n ShippingChargesPayment = self.client.factory.create('Payment')\\r\\n ShippingChargesPayment.Payor = Payor\\r\\n\\r\\n self.RequestedShipment.ShippingChargesPayment = ShippingChargesPayment\\r\\n \\r\\n # ACCOUNT or LIST\\r\\n self.RequestedShipment.RateRequestTypes = ['ACCOUNT'] \\r\\n \\r\\n # Start with no packages, user must add them.\\r\\n self.RequestedShipment.PackageCount = 0\\r\\n self.RequestedShipment.RequestedPackageLineItems = []\\r\\n \\r\\n # This is good to review if you'd like to see what the data structure\\r\\n # looks like.\\r\\n self.logger.debug(self.RequestedShipment)\",\n \"def test_hidden_instantiate(self):\\n context = self.framework.get_bundle_context()\\n\\n # Prepare random values\\n hidden_value = random.randint(0, 100)\\n public_value = random.randint(0, 100)\\n\\n # Instantiate the component\\n with use_ipopo(context) as ipopo:\\n svc = ipopo.instantiate(self.module.FACTORY_HIDDEN_PROPS, NAME_A,\\n {\\\"hidden.prop\\\": hidden_value,\\n \\\"public.prop\\\": public_value})\\n\\n # Check default values (and accesses)\\n self.assertEqual(svc.hidden, hidden_value)\\n self.assertEqual(svc.public, public_value)\\n\\n # Check instance details\\n with use_ipopo(context) as ipopo:\\n details = ipopo.get_instance_details(NAME_A)\\n\\n self.assertNotIn(\\\"hidden.prop\\\", details[\\\"properties\\\"])\",\n \"def make_instance(self, data, **kwargs):\\n instance = self.instance or self.get_instance(data)\\n if instance is not None:\\n for key, value in iteritems(data):\\n setattr(instance, key, value)\\n return instance\\n kwargs, association_attrs = self._split_model_kwargs_association(data)\\n instance = self.opts.model(**kwargs)\\n for attr, value in iteritems(association_attrs):\\n setattr(instance, attr, value)\\n return instance\",\n \"def use_instance_table(self, name, typename):\\n if typename in ['VkInstance', 'VkPhysicalDevice']:\\n return True\\n # vkSetDebugUtilsObjectNameEXT and vkSetDebugUtilsObjectTagEXT\\n # need to be probed from GetInstanceProcAddress due to a loader issue.\\n # https://github.com/KhronosGroup/Vulkan-Loader/issues/1109\\n # TODO : When loader with fix for issue is widely available, remove this\\n # special case.\\n if name in ['vkSetDebugUtilsObjectNameEXT', 'vkSetDebugUtilsObjectTagEXT']:\\n return True\\n return False\",\n \"def create_instance(c_instance):\\n return OpenLabs(c_instance)\",\n \"def build_from_mongo(cls, data, use_cls=True):\\n # If a _cls is specified, we have to use this document class\\n if use_cls and '_cls' in data:\\n cls = cls.opts.instance.retrieve_embedded_document(data['_cls'])\\n doc = cls()\\n doc.from_mongo(data)\\n return doc\",\n \"def from_file(cls, wsdl_path):\\n return cls(safe_parse_path(wsdl_path))\",\n \"def ontology_instance(self,target=None,path=None,value=None,**kwargs):\\n\\n if target == None or path == None or value == None:\\n print(\\\"Usage: ontology_instance target path value\\\",file=sys.stderr)\\n sys.exit(2)\\n\\n force = kwargs.get('force')\\n\\n payload={\\\"path\\\":path,\\\"value\\\":value}\\n if force:\\n r=self.put(self.ONTOLOGY_INSTANCE_RT,target,payload,**kwargs)\\n else:\\n r=self.post(self.ONTOLOGY_INSTANCE_RT,None,target,payload,**kwargs)\\n\\n return r\",\n \"def add_instance(\\n self,\\n name,\\n base_config_dir=None,\\n main_configs=None,\\n user_configs=None,\\n dictionaries=None,\\n macros=None,\\n with_zookeeper=False,\\n with_zookeeper_secure=False,\\n with_mysql_client=False,\\n with_mysql=False,\\n with_mysql8=False,\\n with_mysql_cluster=False,\\n with_kafka=False,\\n with_kerberized_kafka=False,\\n with_kerberos_kdc=False,\\n with_secrets=False,\\n with_rabbitmq=False,\\n with_nats=False,\\n clickhouse_path_dir=None,\\n with_odbc_drivers=False,\\n with_postgres=False,\\n with_postgres_cluster=False,\\n with_postgresql_java_client=False,\\n clickhouse_log_file=CLICKHOUSE_LOG_FILE,\\n clickhouse_error_log_file=CLICKHOUSE_ERROR_LOG_FILE,\\n with_hdfs=False,\\n with_kerberized_hdfs=False,\\n with_mongo=False,\\n with_mongo_secure=False,\\n with_meili=False,\\n with_nginx=False,\\n with_redis=False,\\n with_minio=False,\\n with_azurite=False,\\n with_cassandra=False,\\n with_jdbc_bridge=False,\\n with_hive=False,\\n with_coredns=False,\\n allow_analyzer=True,\\n hostname=None,\\n env_variables=None,\\n image=\\\"clickhouse/integration-test\\\",\\n tag=None,\\n stay_alive=False,\\n ipv4_address=None,\\n ipv6_address=None,\\n with_installed_binary=False,\\n external_dirs=None,\\n tmpfs=None,\\n zookeeper_docker_compose_path=None,\\n minio_certs_dir=None,\\n minio_data_dir=None,\\n use_keeper=True,\\n main_config_name=\\\"config.xml\\\",\\n users_config_name=\\\"users.xml\\\",\\n copy_common_configs=True,\\n config_root_name=\\\"clickhouse\\\",\\n extra_configs=[],\\n ) -> \\\"ClickHouseInstance\\\":\\n\\n if self.is_up:\\n raise Exception(\\\"Can't add instance %s: cluster is already up!\\\" % name)\\n\\n if name in self.instances:\\n raise Exception(\\n \\\"Can't add instance `%s': there is already an instance with the same name!\\\"\\n % name\\n )\\n\\n if tag is None:\\n tag = self.docker_base_tag\\n if not env_variables:\\n env_variables = {}\\n\\n self.use_keeper = use_keeper\\n\\n # Code coverage files will be placed in database directory\\n # (affect only WITH_COVERAGE=1 build)\\n env_variables[\\n \\\"LLVM_PROFILE_FILE\\\"\\n ] = \\\"/var/lib/clickhouse/server_%h_%p_%m.profraw\\\"\\n\\n clickhouse_start_command = CLICKHOUSE_START_COMMAND\\n if clickhouse_log_file:\\n clickhouse_start_command += \\\" --log-file=\\\" + clickhouse_log_file\\n if clickhouse_error_log_file:\\n clickhouse_start_command += \\\" --errorlog-file=\\\" + clickhouse_error_log_file\\n logging.debug(f\\\"clickhouse_start_command: {clickhouse_start_command}\\\")\\n\\n instance = ClickHouseInstance(\\n cluster=self,\\n base_path=self.base_dir,\\n name=name,\\n base_config_dir=base_config_dir\\n if base_config_dir\\n else self.base_config_dir,\\n custom_main_configs=main_configs or [],\\n custom_user_configs=user_configs or [],\\n custom_dictionaries=dictionaries or [],\\n macros=macros or {},\\n with_zookeeper=with_zookeeper,\\n zookeeper_config_path=self.zookeeper_config_path,\\n with_mysql_client=with_mysql_client,\\n with_mysql=with_mysql,\\n with_mysql8=with_mysql8,\\n with_mysql_cluster=with_mysql_cluster,\\n with_kafka=with_kafka,\\n with_kerberized_kafka=with_kerberized_kafka,\\n with_kerberos_kdc=with_kerberos_kdc,\\n with_rabbitmq=with_rabbitmq,\\n with_nats=with_nats,\\n with_nginx=with_nginx,\\n with_kerberized_hdfs=with_kerberized_hdfs,\\n with_secrets=with_secrets\\n or with_kerberized_hdfs\\n or with_kerberos_kdc\\n or with_kerberized_kafka,\\n with_mongo=with_mongo or with_mongo_secure,\\n with_meili=with_meili,\\n with_redis=with_redis,\\n with_minio=with_minio,\\n with_azurite=with_azurite,\\n with_jdbc_bridge=with_jdbc_bridge,\\n with_hive=with_hive,\\n with_coredns=with_coredns,\\n with_cassandra=with_cassandra,\\n allow_analyzer=allow_analyzer,\\n server_bin_path=self.server_bin_path,\\n odbc_bridge_bin_path=self.odbc_bridge_bin_path,\\n library_bridge_bin_path=self.library_bridge_bin_path,\\n clickhouse_path_dir=clickhouse_path_dir,\\n with_odbc_drivers=with_odbc_drivers,\\n with_postgres=with_postgres,\\n with_postgres_cluster=with_postgres_cluster,\\n with_postgresql_java_client=with_postgresql_java_client,\\n clickhouse_start_command=clickhouse_start_command,\\n main_config_name=main_config_name,\\n users_config_name=users_config_name,\\n copy_common_configs=copy_common_configs,\\n hostname=hostname,\\n env_variables=env_variables,\\n image=image,\\n tag=tag,\\n stay_alive=stay_alive,\\n ipv4_address=ipv4_address,\\n ipv6_address=ipv6_address,\\n with_installed_binary=with_installed_binary,\\n external_dirs=external_dirs,\\n tmpfs=tmpfs or [],\\n config_root_name=config_root_name,\\n extra_configs=extra_configs,\\n )\\n\\n docker_compose_yml_dir = get_docker_compose_path()\\n\\n self.instances[name] = instance\\n if ipv4_address is not None or ipv6_address is not None:\\n self.with_net_trics = True\\n self.base_cmd.extend(\\n [\\\"--file\\\", p.join(docker_compose_yml_dir, \\\"docker_compose_net.yml\\\")]\\n )\\n\\n self.base_cmd.extend([\\\"--file\\\", instance.docker_compose_path])\\n\\n cmds = []\\n if with_zookeeper_secure and not self.with_zookeeper_secure:\\n cmds.append(\\n self.setup_zookeeper_secure_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_zookeeper and not self.with_zookeeper:\\n if self.use_keeper:\\n cmds.append(\\n self.setup_keeper_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n else:\\n cmds.append(\\n self.setup_zookeeper_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_mysql_client and not self.with_mysql_client:\\n cmds.append(\\n self.setup_mysql_client_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_mysql and not self.with_mysql:\\n cmds.append(\\n self.setup_mysql_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_mysql8 and not self.with_mysql8:\\n cmds.append(\\n self.setup_mysql8_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_mysql_cluster and not self.with_mysql_cluster:\\n cmds.append(\\n self.setup_mysql_cluster_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_postgres and not self.with_postgres:\\n cmds.append(\\n self.setup_postgres_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_postgres_cluster and not self.with_postgres_cluster:\\n cmds.append(\\n self.setup_postgres_cluster_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_postgresql_java_client and not self.with_postgresql_java_client:\\n cmds.append(\\n self.setup_postgresql_java_client_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_odbc_drivers and not self.with_odbc_drivers:\\n self.with_odbc_drivers = True\\n if not self.with_mysql:\\n cmds.append(\\n self.setup_mysql_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if not self.with_postgres:\\n cmds.append(\\n self.setup_postgres_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_kafka and not self.with_kafka:\\n cmds.append(\\n self.setup_kafka_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_kerberized_kafka and not self.with_kerberized_kafka:\\n cmds.append(\\n self.setup_kerberized_kafka_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_kerberos_kdc and not self.with_kerberos_kdc:\\n cmds.append(\\n self.setup_kerberos_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_rabbitmq and not self.with_rabbitmq:\\n cmds.append(\\n self.setup_rabbitmq_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_nats and not self.with_nats:\\n cmds.append(\\n self.setup_nats_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_nginx and not self.with_nginx:\\n cmds.append(\\n self.setup_nginx_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_hdfs and not self.with_hdfs:\\n cmds.append(\\n self.setup_hdfs_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_kerberized_hdfs and not self.with_kerberized_hdfs:\\n cmds.append(\\n self.setup_kerberized_hdfs_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if (with_mongo or with_mongo_secure) and not (\\n self.with_mongo or self.with_mongo_secure\\n ):\\n if with_mongo_secure:\\n cmds.append(\\n self.setup_mongo_secure_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n else:\\n cmds.append(\\n self.setup_mongo_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_coredns and not self.with_coredns:\\n cmds.append(\\n self.setup_coredns_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_meili and not self.with_meili:\\n cmds.append(\\n self.setup_meili_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if self.with_net_trics:\\n for cmd in cmds:\\n cmd.extend(\\n [\\\"--file\\\", p.join(docker_compose_yml_dir, \\\"docker_compose_net.yml\\\")]\\n )\\n\\n if with_redis and not self.with_redis:\\n cmds.append(\\n self.setup_redis_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_minio and not self.with_minio:\\n cmds.append(\\n self.setup_minio_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if with_azurite and not self.with_azurite:\\n cmds.append(\\n self.setup_azurite_cmd(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n if minio_certs_dir is not None:\\n if self.minio_certs_dir is None:\\n self.minio_certs_dir = minio_certs_dir\\n else:\\n raise Exception(\\\"Overwriting minio certs dir\\\")\\n\\n if minio_data_dir is not None:\\n if self.minio_data_dir is None:\\n self.minio_data_dir = minio_data_dir\\n else:\\n raise Exception(\\\"Overwriting minio data dir\\\")\\n\\n if with_cassandra and not self.with_cassandra:\\n cmds.append(\\n self.setup_cassandra_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_jdbc_bridge and not self.with_jdbc_bridge:\\n cmds.append(\\n self.setup_jdbc_bridge_cmd(\\n instance, env_variables, docker_compose_yml_dir\\n )\\n )\\n\\n if with_hive:\\n cmds.append(\\n self.setup_hive(instance, env_variables, docker_compose_yml_dir)\\n )\\n\\n logging.debug(\\n \\\"Cluster name:{} project_name:{}. Added instance name:{} tag:{} base_cmd:{} docker_compose_yml_dir:{}\\\".format(\\n self.name,\\n self.project_name,\\n name,\\n tag,\\n self.base_cmd,\\n docker_compose_yml_dir,\\n )\\n )\\n return instance\",\n \"def __init__(self):\\n\\t\\tself.parsed = False\\n\\t\\tdir_path = os.path.dirname(os.path.realpath(__file__))\\n\\t\\tself.xsdfilename = os.path.join(dir_path, 'xml', 'schema.xsd')\\n\\t\\tself.schema = 'schema.xsd'\\n\\t\\tself.predictors = []\\n\\t\\tself.predictors_types = []\\n\\t\\tself.preprocessing_methods = []\",\n \"def _prepare_wsdl_objects(self):\\r\\n # This is the primary data structure for processShipment requests.\\r\\n self.RequestedShipment = self.client.factory.create('RequestedShipment')\\r\\n self.RequestedShipment.ShipTimestamp = datetime.now()\\r\\n \\r\\n TotalWeight = self.client.factory.create('Weight')\\r\\n # Start at nothing.\\r\\n TotalWeight.Value = 0.0\\r\\n # Default to pounds.\\r\\n TotalWeight.Units = 'LB'\\r\\n # This is the total weight of the entire shipment. Shipments may\\r\\n # contain more than one package.\\r\\n self.RequestedShipment.TotalWeight = TotalWeight\\r\\n \\r\\n # This is the top level data structure for Shipper information.\\r\\n ShipperParty = self.client.factory.create('Party')\\r\\n ShipperParty.Address = self.client.factory.create('Address')\\r\\n ShipperParty.Contact = self.client.factory.create('Contact')\\r\\n \\r\\n # Link the ShipperParty to our master data structure.\\r\\n self.RequestedShipment.Shipper = ShipperParty\\r\\n\\r\\n # This is the top level data structure for Recipient information.\\r\\n RecipientParty = self.client.factory.create('Party')\\r\\n RecipientParty.Contact = self.client.factory.create('Contact')\\r\\n RecipientParty.Address = self.client.factory.create('Address')\\r\\n \\r\\n # Link the RecipientParty object to our master data structure.\\r\\n self.RequestedShipment.Recipient = RecipientParty\\r\\n \\r\\n Payor = self.client.factory.create('Payor')\\r\\n # Grab the account number from the FedexConfig object by default.\\r\\n Payor.AccountNumber = self._config_obj.account_number\\r\\n # Assume US.\\r\\n Payor.CountryCode = 'US'\\r\\n \\r\\n ShippingChargesPayment = self.client.factory.create('Payment')\\r\\n ShippingChargesPayment.Payor = Payor\\r\\n\\r\\n self.RequestedShipment.ShippingChargesPayment = ShippingChargesPayment\\r\\n self.RequestedShipment.LabelSpecification = self.client.factory.create('LabelSpecification')\\r\\n # ACCOUNT or LIST\\r\\n self.RequestedShipment.RateRequestTypes = ['ACCOUNT'] \\r\\n \\r\\n # Start with no packages, user must add them.\\r\\n self.RequestedShipment.PackageCount = 0\\r\\n self.RequestedShipment.RequestedPackageLineItems = []\\r\\n \\r\\n # This is good to review if you'd like to see what the data structure\\r\\n # looks like.\\r\\n self.logger.debug(self.RequestedShipment)\",\n \"def __init__(self, name, pair_instance, dof_cls):\\n self._name = name\\n self._dof_cls = dof_cls\\n self._pair_instance = pair_instance\\n self._indexer = hoomd.data.parameterdicts._SmartTypeIndexer(2)\\n self._data = {}\",\n \"def load_class_variables(cls, app_configs):\\n cls.is_connected = False # Set is_connected to false initially\\n \\n validate_fields(['sdlp_host', 'sdlp_wsdl', 'sdlp_username', 'sdlp_password', 'sdlp_savedreportid', 'sdlp_incident_endpoint'], kwargs=app_configs)\\n\\n LOG.debug(\\\"Validated Mandatory app.configs for DLPSoapClient\\\")\\n\\n cls.host = app_configs.get('sdlp_host')\\n cls.wsdl = app_configs.get('sdlp_wsdl')\\n # Gather the DLP User Name\\n cls.dlp_username = app_configs.get('sdlp_username')\\n # Gather the DLP User Password\\n cls.dlp_password = app_configs.get('sdlp_password')\\n\\n # Gather the DLP Cert\\n cls.dlp_cert = app_configs.get('sdlp_cafile', False)\\n\\n # Gather the DLP Saved Report ID\\n cls.dlp_saved_report_id = app_configs.get('sdlp_savedreportid')\\n\\n # Gather the DLP Incident Endpoint\\n cls.sdlp_incident_endpoint = app_configs.get('sdlp_incident_endpoint')\\n\\n cls.session = Session()\\n # Use DLP Cert if provided or if None, set verify to false\\n cls.session.verify = cls.dlp_cert\\n cls.session.auth = SymantecAuth(cls.dlp_username, cls.dlp_password, cls.host)\\n\\n\\n mimefile_abs_path = os.path.join(\\n os.path.dirname(os.path.realpath(__file__)),\\n os.path.pardir, \\\"data\\\", \\\"xmlmime.xml\\\")\\n # If the Xmlmime file was provided\\n if os.path.isfile(mimefile_abs_path):\\n LOG.info(\\\"A Local XML file was found in the data directory, %s \\\\n Loading this into the cache\\\", mimefile_abs_path)\\n # Open it and add it to a Cache\\n with open(mimefile_abs_path, mode=\\\"rb\\\") as f:\\n filecontent = f.read()\\n dlp_cache = InMemoryCache()\\n dlp_cache.add(\\\"http://www.w3.org/2005/05/xmlmime\\\", filecontent)\\n dlp_cache.add(\\\"https://www.w3.org/2005/05/xmlmime\\\", filecontent)\\n # Setup Transport with credentials and the cached mimefile\\n cls.transport = zeep.Transport(session=cls.session, cache=dlp_cache)\\n else:\\n # Setup Transport with our credentials\\n cls.transport = zeep.Transport(session=cls.session)\\n\\n try: # Try to create a soap_client from the wsdl and transport\\n cls.soap_client = zeep.Client(wsdl=cls.wsdl, transport=cls.transport)\\n except Exception as caught_exc: # We got an error when setting up a client, catch and release the error in logs so circuits doesn't stop\\n # Put the traceback into DEBUG\\n LOG.debug(traceback.format_exc())\\n # Log the Connection error to the user\\n LOG.error(u\\\"Problem: %s\\\", repr(caught_exc))\\n LOG.error(u\\\"[Symantec DLP] Encountered an exception when setting up the SOAP Client\\\")\\n \\n else: # No connection error, client is setup with the URL. Allow the poller to be setup\\n cls.is_connected = True\\n cls.class_vars_loaded = True\",\n \"def create_client(wsdl: str, raw_response: bool = True) -> CachingClient:\\n # We want the raw response as there is an error when Zeep parses the XML\\n settings: Settings = Settings(raw_response=raw_response)\\n\\n # Client that caches the WSDL\\n client: CachingClient = CachingClient(\\n wsdl=wsdl,\\n # TODO: Store PW encrypted\\n wsse=UsernameToken(\\\"n00394gz\\\", \\\"g427Ix19LMB\\\"),\\n settings=settings,\\n )\\n logger.debug(f\\\"Client created\\\")\\n\\n return client\",\n \"def test_instantiation(self):\\n classifier = WidgetClassifier()\\n classifier.load_model()\\n assert(classifier.encoder is not None)\\n assert(classifier.cluster is not None)\\n assert(classifier.telemetry_keys is not None)\",\n \"def from_dict(data, decomposer_=None, rx=None, ax=None):\\n if decomposer_ is not None:\\n decomposer = decomposer_\\n else:\\n decomposer = SOAPDecomposer(**data[\\\"decomposer\\\"])\\n \\n result = SOAPVector(data[\\\"P\\\"], decomposer)\\n result.dcP = data[\\\"dcP\\\"]\\n result.dnP = data[\\\"dnP\\\"]\\n if rx is not None and data[\\\"rx\\\"] is None:# pragma: no cover\\n result.rx = rx\\n else:\\n result.rx = data[\\\"rx\\\"]\\n if ax is not None and data[\\\"ax\\\"] is None:# pragma: no cover\\n result.ax = ax\\n else:\\n result.ax = data[\\\"ax\\\"]\\n \\n if data[\\\"cRDF\\\"] is not None:\\n result.cRDF = DF(data[\\\"dcP\\\"], True, result.rx, decomposer,\\n calculate=False)\\n result.cRDF.df = data[\\\"cRDF\\\"]\\n if data[\\\"nRDF\\\"] is not None:\\n result.nRDF = DF(data[\\\"dnP\\\"], False, result.rx, decomposer,\\n calculate=False)\\n result.nRDF.df = data[\\\"nRDF\\\"]\\n if data[\\\"cADF\\\"] is not None:\\n result.cADF = DF(data[\\\"dcP\\\"], True, result.ax, decomposer,\\n calculate=False)\\n result.cADF.df = data[\\\"cADF\\\"]\\n if data[\\\"nADF\\\"] is not None:\\n result.nADF = DF(data[\\\"dnP\\\"], False, result.ax, decomposer,\\n calculate=False)\\n result.nADF.df = data[\\\"nADF\\\"]\\n\\n return result\",\n \"def test_instanceBuilder(self):\\n instance = igwt.IInstanceFactory(ChangeType()).buildInstance()\\n self.assertTrue(instance is not None)\\n self.assertTrue(isinstance(instance, Change))\",\n \"def newInstance(self, isTraining):\\r\\n #-------------------------------------------------------\\r\\n # Training Data\\r\\n #-------------------------------------------------------\\r\\n if isTraining: \\r\\n if self.dataRef < (self.formatData.numTrainInstances-1):\\r\\n self.dataRef += 1\\r\\n self.currentTrainState = self.formatData.trainFormatted[self.dataRef][0]\\r\\n self.currentTrainPhenotype = self.formatData.trainFormatted[self.dataRef][1]\\r\\n\\r\\n else: #Once learning has completed an epoch (i.e. learning iterations though the entire dataset) it starts back at the first instance in the data)\\r\\n self.resetDataRef(isTraining)\\r\\n #-------------------------------------------------------\\r\\n # Testing Data\\r\\n #-------------------------------------------------------\\r\\n else: \\r\\n if self.dataRef < (self.formatData.numTestInstances-1):\\r\\n self.dataRef += 1\\r\\n self.currentTestState = self.formatData.testFormatted[self.dataRef][0]\\r\\n self.currentTestPhenotype = self.formatData.testFormatted[self.dataRef][1]\",\n \"def load(self, data, session=None, instance=None, transient=False, *args, **kwargs):\\n self._session = session or self._session\\n self._transient = transient or self._transient\\n if not (self.transient or self.session):\\n raise ValueError(\\\"Deserialization requires a session\\\")\\n self.instance = instance or self.instance\\n try:\\n return super(ModelSchema, self).load(data, *args, **kwargs)\\n finally:\\n self.instance = None\",\n \"def get_single_ns_info(self, ns_inst, is_sol=False):\\n if is_sol:\\n nsInstance = {}\\n nsInstance['id'] = ns_inst.id\\n nsInstance['nsInstanceName'] = ns_inst.name\\n nsInstance['nsInstanceDescription'] = ns_inst.description\\n nsInstance['nsdId'] = ns_inst.nsd_id\\n nsInstance['nsdInfoId'] = ns_inst.nspackage_id\\n nsInstance['nsState'] = ns_inst.status\\n if ns_inst.nsd_invariant_id:\\n nsInstance['nsdInvariantId'] = ns_inst.nsd_invariant_id\\n if ns_inst.flavour_id:\\n nsInstance['flavourId'] = ns_inst.flavour_id\\n # todo 'nsScaleStatus':{}\\n # todo 'additionalAffinityOrAntiAffinityRule':{}\\n logger.debug(\\\" test \\\")\\n vnf_instance_list = self.get_vnf_infos(ns_inst.id, is_sol)\\n if vnf_instance_list:\\n nsInstance['vnfInstance'] = vnf_instance_list\\n # todo 'pnfInfo': self.get_pnf_infos(ns_inst.id,is_sol),\\n vl_list = self.get_vl_infos(ns_inst.id, is_sol)\\n if vl_list:\\n nsInstance['virtualLinkInfo'] = vl_list\\n # todo 'vnffgInfo': self.get_vnffg_infos(ns_inst.id, ns_inst.nsd_model),\\n # todo 'sapInfo':{},\\n # todo nestedNsInstanceId\\n logger.debug(\\\" test \\\")\\n nsInstance['_links'] = {\\n 'self': {'href': NS_INSTANCE_BASE_URI % ns_inst.id},\\n 'instantiate': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/instantiate'},\\n 'terminate': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/terminate'},\\n 'update': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/update'},\\n 'scale': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/scale'},\\n 'heal': {'href': NS_INSTANCE_BASE_URI % ns_inst.id + '/heal'}\\n }\\n logger.debug(\\\" test \\\")\\n return nsInstance\\n return {\\n 'nsInstanceId': ns_inst.id,\\n 'nsName': ns_inst.name,\\n 'description': ns_inst.description,\\n 'nsdId': ns_inst.nsd_id,\\n 'nsdInvariantId': ns_inst.nsd_invariant_id,\\n 'vnfInfo': self.get_vnf_infos(ns_inst.id, is_sol),\\n 'pnfInfo': self.get_pnf_infos(ns_inst.id),\\n 'vlInfo': self.get_vl_infos(ns_inst.id, is_sol),\\n 'vnffgInfo': self.get_vnffg_infos(ns_inst.id, ns_inst.nsd_model, is_sol),\\n 'nsState': ns_inst.status}\",\n \"def _get_instance(self):\",\n \"def _get_instance(self):\",\n \"def create_instance(self, date):\\n raise NotImplementedError\",\n \"def create_instance(self, **attrs):\\n return self._create(_instance.Instance, **attrs)\",\n \"def create(self):\\n raise WufooException(\\\"InstanceResource creation not supported\\\")\",\n \"def __init__(self):\\n self.id = None\\n \\\"\\\"\\\"\\\"true if individual services can be enabled/disabled\\\"\\\"\\\"\\n self.canenableindividualservice = None\\n \\\"\\\"\\\"\\\"the destination physical network\\\"\\\"\\\"\\n self.destinationphysicalnetworkid = None\\n \\\"\\\"\\\"\\\"the provider name\\\"\\\"\\\"\\n self.name = None\\n \\\"\\\"\\\"\\\"the physical network this belongs to\\\"\\\"\\\"\\n self.physicalnetworkid = None\\n \\\"\\\"\\\"\\\"services for this provider\\\"\\\"\\\"\\n self.servicelist = None\\n \\\"\\\"\\\"\\\"state of the network provider\\\"\\\"\\\"\\n self.state = None\",\n \"def _is_dataclass_instance(obj):\\n return hasattr(type(obj), '__dataclass_fields__')\",\n \"def do_instance_start(self, component_handle, instance_handle):\\n logger.debug(\\\"RwdtstaskletPython: do_instance_start function called\\\")\\n\\n # Create an instance of DTS API - This object is needed by all DTS\\n # member and query APIs directly or indirectly.\\n # DTS invokes the callback to notify the tasklet that the DTS API instance is ready \\n # for use.\\n\\n foo = Callback()\\n #sub = SubscribeInsideXactExample(self)\\n self.dts_api = RwDts.Api.new(self.taskletinfo, # tasklet object\\n RwDtsToyTaskletYang.get_schema(), # Schema object\\n foo.rwdts_tasklet_state_change_cb, # The callback for DTS state change\\n #sub.rwdts_tasklet_state_change_cb,\\n self) # user data in the callback - in this case self\",\n \"def __init__(self, dry_run=False):\\n\\t\\t# TODO(jchaloup):\\n\\t\\t# - inject the product together with buildsystem client\\n\\t\\t# TODO(jchaloup):\\n\\t\\t# - inject the act and replace it with datasource instead\\n\\t\\t# so the artefact/data can be picked from more sources\",\n \"def prepare_instance(self, idx):\\n instance = self.instances[idx]\\n component = instance['components'][0]\\n \\n results = self.prepare_component(instance, component,instance['dec_per'])\\n return results\",\n \"def GetInstance():\\n pass\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id_conta': 'int',\\n 'id_produto': 'int',\\n 'id_pessoa': 'int',\\n 'id_parentesco': 'int',\\n 'tipo_portador': 'str',\\n 'nome_impresso': 'str',\\n 'id_tipo_cartao': 'int',\\n 'flag_ativo': 'int',\\n 'data_cadastro_portador': 'str',\\n 'data_cancelamento_portador': 'str'\\n }\\n\\n self.attribute_map = {\\n 'id_conta': 'idConta',\\n 'id_produto': 'idProduto',\\n 'id_pessoa': 'idPessoa',\\n 'id_parentesco': 'idParentesco',\\n 'tipo_portador': 'tipoPortador',\\n 'nome_impresso': 'nomeImpresso',\\n 'id_tipo_cartao': 'idTipoCartao',\\n 'flag_ativo': 'flagAtivo',\\n 'data_cadastro_portador': 'dataCadastroPortador',\\n 'data_cancelamento_portador': 'dataCancelamentoPortador'\\n }\\n\\n self._id_conta = None\\n self._id_produto = None\\n self._id_pessoa = None\\n self._id_parentesco = None\\n self._tipo_portador = None\\n self._nome_impresso = None\\n self._id_tipo_cartao = None\\n self._flag_ativo = None\\n self._data_cadastro_portador = None\\n self._data_cancelamento_portador = None\",\n \"def __init__(self, instance=None):\\n self.instance = instance\\n self.schema = None\\n if self.instance:\\n self.schema = surveys.SurveySchema(self.instance.survey)\",\n \"def _new_instance(cls, data, wcs, errors=None, **kwargs):\\n return cls(data, wcs, errors=errors, **kwargs)\",\n \"def __init__(self, py_dict=None):\\n super(TypeSchema, self).__init__()\\n self.set_data_type('xml')\\n\\n self.typeName = None\",\n \"def __call__(self,setup_options=True, instantiate_options=True, verbose=False):\\n model = self.setup(setup_options)\\n model(instantiate_options, verbose)\\n return model\",\n \"def __init__(self, py_dict=None):\\n super(PagedSystemEventListSchema, self).__init__()\\n self.set_data_type(\\\"xml\\\")\\n self.dataPage = DataPageSchema()\\n\\n\\n if py_dict is not None:\\n self.get_object_from_py_dict(py_dict)\",\n \"def create_instance(self, data_defs):\\n if not data_defs:\\n msg = 'No data definitions are provided.'\\n raise AppResponseException(msg)\\n\\n if (any(dd.source.name == 'packets' for dd in data_defs)\\n and any(dd.source.name != 'packets' for dd in data_defs)):\\n # Two report instance needs to be created, one uses 'npm.reports'\\n # service, the other one uses 'npm.probe.reports' service\\n # it would create unnecessary complexity to support this case\\n # thus report error and let the user to create two separate\\n # report instances\\n\\n msg = ('Both packets data source and non-packets data source are '\\n 'being queried in this report, which is not supported. The '\\n 'data source names include {}'\\n .format(', '.join(set([dd.source.name\\n for dd in data_defs]))))\\n raise AppResponseException(msg)\\n\\n def _create_and_run(service_name, data_defs):\\n\\n config = dict(data_defs=[dd.to_dict() for dd in data_defs])\\n logger.debug(\\\"Creating instance with data definitions %s\\\" % config)\\n\\n svcdef = self.appresponse.find_service(service_name)\\n datarep = svcdef.bind('instances')\\n resp = datarep.execute('create', _data=config)\\n\\n instance = ReportInstance(data=resp.data, datarep=resp)\\n while not instance.is_complete():\\n time.sleep(1)\\n\\n if instance.errors:\\n err_msgs = ';\\\\n'.join(instance.errors)\\n raise AppResponseException(err_msgs)\\n\\n return instance\\n\\n if data_defs[0].source.name == 'packets':\\n # Needs to create a clip for for capture job packets source\\n # Keep the clip till the instance is completed\\n with self.appresponse.clips.create_clips(data_defs):\\n # capture job data_defs are modified in place\\n instance = _create_and_run(PACKETS_REPORT_SERVICE_NAME,\\n data_defs)\\n else:\\n instance = _create_and_run(GENERAL_REPORT_SERVICE_NAME,\\n data_defs)\\n return instance\",\n \"def create(self, validated_data):\\n security_groups = validated_data.pop('security_groups', [])\\n internal_ips = validated_data.pop('internal_ips_set', [])\\n floating_ips_with_subnets = validated_data.pop('floating_ips', [])\\n spl = validated_data['service_project_link']\\n ssh_key = validated_data.get('ssh_public_key')\\n if ssh_key:\\n # We want names to be human readable in backend.\\n # OpenStack only allows latin letters, digits, dashes, underscores and spaces\\n # as key names, thus we mangle the original name.\\n safe_name = re.sub(r'[^-a-zA-Z0-9 _]+', '_', ssh_key.name)[:17]\\n validated_data['key_name'] = '{0}-{1}'.format(ssh_key.uuid.hex, safe_name)\\n validated_data['key_fingerprint'] = ssh_key.fingerprint\\n\\n flavor = validated_data['flavor']\\n validated_data['flavor_name'] = flavor.name\\n validated_data['cores'] = flavor.cores\\n validated_data['ram'] = flavor.ram\\n validated_data['flavor_disk'] = flavor.disk\\n\\n image = validated_data['image']\\n validated_data['image_name'] = image.name\\n validated_data['min_disk'] = image.min_disk\\n validated_data['min_ram'] = image.min_ram\\n\\n system_volume_size = validated_data['system_volume_size']\\n data_volume_size = validated_data.get('data_volume_size', 0)\\n validated_data['disk'] = data_volume_size + system_volume_size\\n\\n instance = super(InstanceSerializer, self).create(validated_data)\\n\\n # security groups\\n instance.security_groups.add(*security_groups)\\n # internal IPs\\n for internal_ip in internal_ips:\\n internal_ip.instance = instance\\n internal_ip.save()\\n # floating IPs\\n for floating_ip, subnet in floating_ips_with_subnets:\\n _connect_floating_ip_to_instance(floating_ip, subnet, instance)\\n # volumes\\n volumes = []\\n system_volume = models.Volume.objects.create(\\n name='{0}-system'.format(instance.name[:143]), # volume name cannot be longer than 150 symbols\\n service_project_link=spl,\\n size=system_volume_size,\\n image=image,\\n image_name=image.name,\\n bootable=True,\\n )\\n volumes.append(system_volume)\\n\\n if data_volume_size:\\n data_volume = models.Volume.objects.create(\\n name='{0}-data'.format(instance.name[:145]), # volume name cannot be longer than 150 symbols\\n service_project_link=spl,\\n size=data_volume_size,\\n )\\n volumes.append(data_volume)\\n\\n for volume in volumes:\\n volume.increase_backend_quotas_usage()\\n\\n instance.volumes.add(*volumes)\\n return instance\",\n \"def __init__(self, doc: Dict, validate: Optional[bool] = True):\\n self.doc = doc\\n if validate:\\n jsonschema.validate(instance=doc, schema=DESCRIPTOR_SCHEMA)\",\n \"def __init__(self, use_spacy=True):\\n self._use_spacy = use_spacy\",\n \"def configure_stp_instance(self, instance, **kwargs):\\n pass\",\n \"def __init__(self, options):\\n # option[0] = true means use all instances to calculate the w, w0.\\n # option[0] = false means use SDG to calculate the w, w0.\\n self.gradients_type = options[0]\\n self.X_train = options[1]\\n self.y_train = options[2]\\n self.X_test = options[3]\\n self.y_test = options[4]\\n self.X = options[5]\\n self.y = options[6]\\n # initial w select zeros\\n self.lamda = 0.1\\n self.w_result = 0\\n self.tim = []\\n self.los_plt = []\",\n \"def test_load_str(self):\\n o = \\\"soap\\\"\\n cls = pytan3.adapters.load(o)\\n assert issubclass(cls, pytan3.adapters.Soap)\",\n \"def __init__(self, mxd, servicename, url, datasources):\\n self.name = servicename\\n self.url = url\\n self.mxd = mxd\\n self._dbnames = sorted(datasources.keys())\\n self._featureclasses = [y for x in datasources.values() for y in x]\\n self._datastructure = datasources\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'discovery': 'Discovery',\\n 'groups': 'list[str]',\\n 'labels': 'object'\\n }\\n\\n self.attribute_map = {\\n 'discovery': 'discovery',\\n 'groups': 'groups',\\n 'labels': 'labels'\\n }\\n\\n self._discovery = None\\n self._groups = None\\n self._labels = None\",\n \"def make_instance(scene, features, params, instances, direction,\\n focus_measures, classification, weight):\\n evaluator = action_feature_evaluator(focus_measures, scene.step_count)\\n\\n # Randomly select only a subset of instances based on their weight.\\n if params.outlierHandling == OutlierHandling.SAMPLING:\\n if random.random() <= weight * params.uniformSamplingRate:\\n instance = ( [ evaluator(feature) for _, feature in features ], \\n classification )\\n instances.append(instance)\\n elif params.outlierHandling == OutlierHandling.WEIGHTING:\\n if random.random() <= params.uniformSamplingRate:\\n instance = ( [ evaluator(feature) for _, feature in features ], \\n classification, weight )\\n instances.append(instance)\\n else:\\n assert False\",\n \"def __init__(self, instance_or_wire):\\n super(TimeSeries, self).__init__()\\n\\n self._collection = None\\n self._data = None\\n\\n if isinstance(instance_or_wire, TimeSeries):\\n # copy ctor\\n # pylint: disable=protected-access\\n self._collection = instance_or_wire._collection\\n self._data = instance_or_wire._data\\n\\n elif isinstance(instance_or_wire, dict):\\n if 'events' in instance_or_wire:\\n # list of events dict(name='events', events=[list, of, events])\\n\\n self._collection = Collection(instance_or_wire.get('events', []))\\n\\n meta = copy.copy(instance_or_wire)\\n meta.pop('events')\\n\\n self._data = self.build_metadata(meta)\\n\\n elif 'collection' in instance_or_wire:\\n # collection dict(name='collection', collection=collection_obj)\\n\\n self._collection = instance_or_wire.get('collection', None)\\n\\n meta = copy.copy(instance_or_wire)\\n meta.pop('collection')\\n\\n self._data = self.build_metadata(meta)\\n\\n elif 'columns' in instance_or_wire and 'points' in instance_or_wire:\\n # coming from the wire format\\n\\n event_type = instance_or_wire.get('columns')[0]\\n event_fields = instance_or_wire.get('columns')[1:]\\n\\n events = list()\\n\\n for i in instance_or_wire.get('points'):\\n time = i[0]\\n event_values = i[1:]\\n data = dict(list(zip(event_fields, event_values)))\\n try:\\n events.append(self.event_type_map[event_type](time, data))\\n except KeyError:\\n msg = 'invalid event type {et}'.format(et=event_type)\\n raise TimeSeriesException(msg)\\n\\n self._collection = Collection(events)\\n\\n meta = copy.copy(instance_or_wire)\\n meta.pop('columns')\\n meta.pop('points')\\n\\n self._data = self.build_metadata(meta)\\n\\n else:\\n msg = 'unable to determine dict format'\\n raise TimeSeriesException(msg)\\n else:\\n # unable to determine\\n msg = 'arg must be a TimeSeries instance or dict'\\n raise TimeSeriesException(msg)\\n\\n if self._collection.is_chronological() is not True:\\n msg = 'Events supplied to TimeSeries constructor must be chronological'\\n raise TimeSeriesException(msg)\",\n \"def __init__(self, py_dict=None):\\n super(EventThresholdsSchema, self).__init__()\\n self.set_data_type(\\\"xml\\\")\\n self.cpu = CpuSchema()\\n self.memory = MemorySchema()\\n self.connectionsPerSecond = CpsSchema()\\n\\n\\n if py_dict is not None:\\n self.get_object_from_py_dict(py_dict)\",\n \"def restore_object(self, attrs, instance=None):\\n if instance:\\n # update existing instance\\n instance.name = attrs.get('name', instance.name)\\n instance.price = attrs.get('price', instance.price)\\n\\n # create new instance\\n return Service(**attrs)\",\n \"def __init__(self, py_dict=None):\\n super(BGPNeighbourSchema, self).__init__()\\n self.set_data_type(\\\"xml\\\")\\n self.bgpFilters = None\\n self.holdDownTimer = None\\n self.weight = None\\n self.remoteAS = None\\n self.protocolAddress = None\\n self.forwardingAddress = None\\n self.password = None\\n self.ipAddress = None\\n self.keepAliveTimer = None\\n\\n if py_dict is not None:\\n self.get_object_from_py_dict(py_dict)\",\n \"def _create_dummy_wsdl(self, xsd):\\n\\n if (path.exists(xsd)):\\n try:\\n with open(xsd, 'r') as f:\\n tns = search(r'targetNamespace=\\\"(.*)\\\"', f.read()).group(1)\\n if ('\\\"' in tns):\\n tns = tns[: tns.index('\\\"')]\\n\\n filename = xsd.split('/')[-1]\\n wsdl = path.abspath(xsd)[:-3] + 'wsdl'\\n\\n with open(wsdl, 'w') as f:\\n f.write(wsdl_tmpl.format(tns, tns, tns, filename))\\n\\n return wsdl\\n except AttributeError as ex:\\n raise ValueError('File {0} is not valid XSD'.format(xsd))\\n\\n else:\\n raise ValueError('File {0} not found'.format(xsd))\",\n \"def startInstance(self, name=None,\\n location=None,\\n familyName=None,\\n styleName=None,\\n fileName=None,\\n postScriptFontName=None,\\n styleMapFamilyName=None,\\n styleMapStyleName=None,\\n\\n ):\\n if self.currentInstance is not None:\\n # We still have the previous one open\\n self.endInstance()\\n instanceElement = ET.Element('instance')\\n if name is not None:\\n instanceElement.attrib['name'] = name\\n if location is not None:\\n locationElement = self._makeLocationElement(location)\\n instanceElement.append(locationElement)\\n if familyName is not None:\\n instanceElement.attrib['familyname'] = familyName\\n if styleName is not None:\\n instanceElement.attrib['stylename'] = styleName\\n if fileName is not None:\\n instanceElement.attrib['filename'] = self._posixPathRelativeToDocument(fileName)\\n if postScriptFontName is not None:\\n instanceElement.attrib['postscriptfontname'] = postScriptFontName\\n if styleMapFamilyName is not None:\\n instanceElement.attrib['stylemapfamilyname'] = styleMapFamilyName\\n if styleMapStyleName is not None:\\n instanceElement.attrib['stylemapstylename'] = styleMapStyleName\\n\\n self.currentInstance = instanceElement\",\n \"def test_create(self):\\n from supvisors.statistics import StatisticsInstance\\n instance = StatisticsInstance(17, 10)\\n # check attributes\\n self.assertEqual(3, instance.period)\\n self.assertEqual(10, instance.depth)\\n self.assertEqual(-1, instance.counter)\\n self.assertIsNone(instance.ref_stats)\\n self.assertIs(list, type(instance.cpu))\\n self.assertFalse(instance.cpu)\\n self.assertIs(list, type(instance.mem))\\n self.assertFalse(instance.mem)\\n self.assertIs(dict, type(instance.io))\\n self.assertFalse(instance.io)\\n self.assertIs(dict, type(instance.proc))\\n self.assertFalse(instance.proc)\",\n \"def _fill_instance_child(self, xmldoc, element_name, return_type):\\n xmlelements = self._get_child_nodes(xmldoc, self._get_serialization_name(element_name))\\n\\n if not xmlelements:\\n return None\\n\\n return_obj = return_type()\\n self._fill_data_to_return_object(xmlelements[0], return_obj)\\n\\n return return_obj\",\n \"def instantiate(self, features=()):\\n\\n if self._cls and not self._tool:\\n tool = self._cls.instance(features)\\n return getattr(tool, self.name)\\n else:\\n return self\",\n \"def createService(data):\\n return Service(data).create()\",\n \"def __init__(self, name=None, description=None, address_1=None, address_2=None, city=None, county=None, postcode=None, country_id=None, currency_id=None, business_email=None, business_phone=None, vat_number=None, registration_number=None, latitude=None, longitude=None, timezone=None, contact=None, website=None):\\n self.swagger_types = {\\n 'name': 'str',\\n 'description': 'str',\\n 'address_1': 'str',\\n 'address_2': 'str',\\n 'city': 'str',\\n 'county': 'str',\\n 'postcode': 'str',\\n 'country_id': 'int',\\n 'currency_id': 'int',\\n 'business_email': 'str',\\n 'business_phone': 'str',\\n 'vat_number': 'str',\\n 'registration_number': 'str',\\n 'latitude': 'float',\\n 'longitude': 'float',\\n 'timezone': 'str',\\n 'contact': 'str',\\n 'website': 'str'\\n }\\n\\n self.attribute_map = {\\n 'name': 'name',\\n 'description': 'description',\\n 'address_1': 'address_1',\\n 'address_2': 'address_2',\\n 'city': 'city',\\n 'county': 'county',\\n 'postcode': 'postcode',\\n 'country_id': 'country_id',\\n 'currency_id': 'currency_id',\\n 'business_email': 'business_email',\\n 'business_phone': 'business_phone',\\n 'vat_number': 'vat_number',\\n 'registration_number': 'registration_number',\\n 'latitude': 'latitude',\\n 'longitude': 'longitude',\\n 'timezone': 'timezone',\\n 'contact': 'contact',\\n 'website': 'website'\\n }\\n\\n self._name = name\\n self._description = description\\n self._address_1 = address_1\\n self._address_2 = address_2\\n self._city = city\\n self._county = county\\n self._postcode = postcode\\n self._country_id = country_id\\n self._currency_id = currency_id\\n self._business_email = business_email\\n self._business_phone = business_phone\\n self._vat_number = vat_number\\n self._registration_number = registration_number\\n self._latitude = latitude\\n self._longitude = longitude\\n self._timezone = timezone\\n self._contact = contact\\n self._website = website\",\n \"def create_custom():\\n # Extract initialisation parameters\\n alpha = request.args.get('alpha')\\n alpha = float(alpha)\\n generations = request.args.get('generations')\\n generations = int(generations)\\n beta = request.args.get('beta')\\n beta = float(beta)\\n pec = request.args.get('pec')\\n pec = float(pec)\\n q = request.args.get('q')\\n q = float(q)\\n\\n # Extract the custom coordinates and create a list of nodes\\n coords = request.args.get('custom_coords')\\n coords = str(coords)\\n nodes = custom_nodes(coords)\\n\\n # Initialise instance\\n i = Instance(nodes, alpha, beta, pec, q)\\n\\n return jsonify(nodes=i.nodes, alpha=i.alpha, beta=i.beta, decay=i.decay,\\n min_pheromone=i.min_pheromone, q=i.q,\\n local_deposit=i.local_deposit, distances=i.distances,\\n pheromones=i.pheromones, ants=i.ants, shortest_path=i.shortest_path,\\n min_distance=i.min_distance, message=\\\"Instance Initialised\\\")\",\n \"def __init__(self, **kwargs):\\n source = kwargs\\n if 'xml_element' in kwargs:\\n source = kwargs.get('xml_element')\\n validate_xml_element(source, self.ELEMENT_TAG)\\n\\n self.tag = source.get('tag', '')\\n\\n # Some versions of Stop have additional attributes. Only add them to the class if they exist.\\n title = source.get('title')\\n if title:\\n self.title = title\\n\\n short_title = source.get('shortTitle')\\n if short_title:\\n self.short_title = short_title\\n\\n lat = source.get('lat')\\n if lat:\\n self.lat = lat\\n\\n lon = source.get('lon')\\n if lon:\\n self.lon = lon\",\n \"def __init__(self, file_name,\\n word_vocab,\\n max_sent_len,\\n num_class):\\n self.examples = examples = ParseExample.load_data(file_name)\\n\\n instance_id_list = []\\n warrant0_list = []\\n warrant1_list = []\\n correct_label_w0_or_w1_list = []\\n reason_list = []\\n claim_list = []\\n debate_meta_data_list = []\\n\\n warrant0_len = []\\n warrant1_len = []\\n reason_len = []\\n claim_len = []\\n debate_meta_data_len = []\\n\\n for example in examples:\\n warrant0, warrant1, reason, claim, debate_meta_data, negclaim = example.get_six(type=WORD_TYPE)\\n instance_id = example.get_id()\\n correct_label_w0_or_w1 = example.get_label()\\n\\n # convert to the ids\\n warrant0 = data_utils.sent_to_index(warrant0, word_vocab)\\n warrant1 = data_utils.sent_to_index(warrant1, word_vocab)\\n reason = data_utils.sent_to_index(reason, word_vocab)\\n claim = data_utils.sent_to_index(claim, word_vocab)\\n debate_meta_data = data_utils.sent_to_index(debate_meta_data, word_vocab)\\n correct_label_w0_or_w1 = data_utils.onehot_vectorize(correct_label_w0_or_w1, num_class)\\n\\n warrant0_len.append(min(len(warrant0), max_sent_len))\\n warrant1_len.append(min(len(warrant1), max_sent_len))\\n reason_len.append(min(len(reason), max_sent_len))\\n claim_len.append(min(len(claim), max_sent_len))\\n debate_meta_data_len.append(min(len(debate_meta_data), max_sent_len))\\n\\n # add to the result\\n instance_id_list.append(instance_id)\\n warrant0_list.append(warrant0)\\n warrant1_list.append(warrant1)\\n correct_label_w0_or_w1_list.append(correct_label_w0_or_w1)\\n reason_list.append(reason)\\n claim_list.append(claim)\\n debate_meta_data_list.append(debate_meta_data)\\n\\n warrant0_list = data_utils.pad_2d_matrix(warrant0_list, max_sent_len)\\n warrant1_list = data_utils.pad_2d_matrix(warrant1_list, max_sent_len)\\n reason_list = data_utils.pad_2d_matrix(reason_list, max_sent_len)\\n claim_list = data_utils.pad_2d_matrix(claim_list, max_sent_len)\\n debate_meta_data_list = data_utils.pad_2d_matrix(debate_meta_data_list, max_sent_len)\\n\\n # text\\n self.instance_id_list = np.array(instance_id_list)\\n # float\\n self.correct_label_w0_or_w1_list = np.array(correct_label_w0_or_w1_list, dtype=np.float32)\\n # int\\n self.warrant0_list = np.array(warrant0_list, dtype=np.int32)\\n self.warrant1_list = np.array(warrant1_list, dtype=np.int32)\\n self.reason_list = np.array(reason_list, dtype=np.int32)\\n self.claim_list = np.array(claim_list, dtype=np.int32)\\n self.debate_meta_data_list = np.array(debate_meta_data_list, dtype=np.int32)\\n\\n self.warrant0_len = np.array(warrant0_len, dtype=np.int32)\\n self.warrant1_len = np.array(warrant1_len, dtype=np.int32)\\n self.reason_len = np.array(reason_len, dtype=np.int32)\\n self.claim_len = np.array(claim_len, dtype=np.int32)\\n self.debate_meta_data_len = np.array(debate_meta_data_len, dtype=np.int32)\\n\\n self.do_id = word_vocab['do']\\n\\n # obtain the diff part\\n diff_warrant0_list = []\\n diff_warrant1_list = []\\n diff_claim_list = []\\n diff_warrant0_len_list = []\\n diff_warrant1_len_list = []\\n diff_claim_len_list = []\\n id = 0\\n for example in examples:\\n warrant0, warrant1, reason, claim, debate_meta_data, negclaim = example.get_six(type=WORD_TYPE)\\n la, ra, lb, rb = diffsents(warrant0, warrant1)\\n diff_warrant0 = warrant0[la: ra + 1]\\n diff_warrant1 = warrant1[lb: rb + 1]\\n la, ra, _, _ = diffsents(claim, negclaim)\\n diff_claim = claim[la: ra+1]\\n # print(warrant0, warrant1, diff_warrant0, diff_warrant1)\\n # print(claim, negclaim, diff_claim)\\n # id += 1\\n # if id == 10:\\n # exit(1)\\n\\n # convert to the ids\\n diff_warrant0 = data_utils.sent_to_index(diff_warrant0, word_vocab)\\n diff_warrant1 = data_utils.sent_to_index(diff_warrant1, word_vocab)\\n diff_claim = data_utils.sent_to_index(diff_claim, word_vocab)\\n\\n diff_warrant0_list.append(diff_warrant0)\\n diff_warrant1_list.append(diff_warrant1)\\n diff_claim_list.append(diff_claim)\\n\\n diff_warrant0_len_list.append(min(len(diff_warrant0), config.max_diff_len))\\n diff_warrant1_len_list.append(min(len(diff_warrant1), config.max_diff_len))\\n diff_claim_len_list.append(min(len(diff_claim), config.max_diff_len))\\n\\n diff_warrant0_list = data_utils.pad_2d_matrix(diff_warrant0_list, config.max_diff_len)\\n diff_warrant1_list = data_utils.pad_2d_matrix(diff_warrant1_list, config.max_diff_len)\\n diff_claim_list = data_utils.pad_2d_matrix(diff_claim_list, config.max_diff_len)\\n\\n # int\\n self.diff_warrant0_list = np.array(diff_warrant0_list, dtype=np.int32)\\n self.diff_warrant1_list = np.array(diff_warrant1_list, dtype=np.int32)\\n self.diff_claim_list = np.array(diff_claim_list, dtype=np.int32)\\n\\n self.diff_warrant0_len = np.array(diff_warrant0_len_list, dtype=np.int32)\\n self.diff_warrant1_len = np.array(diff_warrant1_len_list, dtype=np.int32)\\n self.diff_claim_len = np.array(diff_claim_len_list, dtype=np.int32)\",\n \"def learn(instance: machine_learning.StationMachineLearning):\\n instance.learn()\",\n \"def __init__(self, use_existing_vocab: bool = True):\\n\\n self._db_connection = postgresql.DatabaseConnection()\\n self._use_existing_vocab = use_existing_vocab\",\n \"def create_stp_instance(self, instance, priority):\\n pass\",\n \"def from_xml(cls, xml_data, system, id_generator):\\r\\n\\r\\n xml_object = etree.fromstring(xml_data)\\r\\n system.error_tracker('WARNING: the <{tag}> tag is deprecated. '\\r\\n 'Instead, use . '\\r\\n .format(tag=xml_object.tag))\\r\\n\\r\\n tag = xml_object.tag\\r\\n xml_object.tag = 'customtag'\\r\\n xml_object.attrib['impl'] = tag\\r\\n\\r\\n return system.process_xml(etree.tostring(xml_object))\",\n \"def build_from_instance(self, instanceDict={}):\\n if not instanceDict.keys():\\n print \\\"Instance's dictionary not provided. Please provide a dictionary that contains instance's information.\\\"\\n return\\n\\n from node import Node\\n from edge import Edge\\n\\n self.__instance_dictionary = instanceDict\\n self.__name = instanceDict[\\\"header\\\"][\\\"NAME\\\"] # name of the graph\\n self.__nodes = [] # Array of nodes\\n self.__num_nodes = 0 # Number of nodes\\n self.__edges = [] # Array of edges\\n self.__num_edges = 0 # Number of edges\\n self.__adjacency_matrix = [] # initialize an empty adjacency matrix\\n self.__adjacency_matrix_dictionary = {} # initialize an empty double dictionary adjacency object\\n\\n # add nodes to the graph\\n for curNodeVal in xrange(0, instanceDict[\\\"header\\\"][\\\"DIMENSION\\\"]):\\n new_node = Node(curNodeVal, instanceDict[\\\"nodes\\\"][curNodeVal]) # create a new node instance\\n self.add_node(new_node) # add node to the graph\\n\\n # add edges to graph\\n for tupleEdge in instanceDict[\\\"edges\\\"]:\\n node_a_id = tupleEdge[0]\\n node_b_id = tupleEdge[1]\\n edge_weight = tupleEdge[2]\\n\\n #if edge_weight > 0:\\n if node_a_id != node_b_id:\\n new_edge = Edge(self.__nodes[node_a_id], self.__nodes[node_b_id], edge_weight) # create edge\\n self.add_edge(new_edge)\",\n \"def _readSingleInstanceElement(\\n self,\\n instanceElement,\\n makeGlyphs=True,\\n makeKerning=True,\\n makeInfo=True,\\n bendLocations=False,\\n ):\\n # get the data from the instanceElement itself\\n filename = instanceElement.attrib.get('filename')\\n\\n instancePath = os.path.join(os.path.dirname(self.path), filename)\\n self.reportProgress(\\\"generate\\\", 'start', instancePath)\\n if self.verbose and self.logger:\\n self.logger.info(\\\"\\\\tGenerating instance %s\\\", os.path.basename(instancePath))\\n filenameTokenForResults = os.path.basename(filename)\\n\\n instanceObject = self._instanceWriterClass(\\n instancePath,\\n ufoVersion=self.ufoVersion,\\n roundGeometry=self.roundGeometry,\\n axes = self.axes,\\n verbose=self.verbose,\\n logger=self.logger,\\n bendLocations=bendLocations,\\n )\\n self.results[filenameTokenForResults] = instancePath\\n\\n # set the masters\\n instanceObject.setSources(self.sources)\\n self.unicodeMap = instanceObject.makeUnicodeMapFromSources()\\n instanceObject.setMuted(self.muted)\\n familyname = instanceElement.attrib.get('familyname')\\n if familyname is not None:\\n instanceObject.setFamilyName(familyname)\\n stylename = instanceElement.attrib.get('stylename')\\n if stylename is not None:\\n instanceObject.setStyleName(stylename)\\n postScriptFontName = instanceElement.attrib.get('postscriptfontname')\\n if postScriptFontName is not None:\\n instanceObject.setPostScriptFontName(postScriptFontName)\\n styleMapFamilyName = instanceElement.attrib.get('stylemapfamilyname')\\n if styleMapFamilyName is not None:\\n instanceObject.setStyleMapFamilyName(styleMapFamilyName)\\n styleMapStyleName = instanceElement.attrib.get('stylemapstylename')\\n if styleMapStyleName is not None:\\n instanceObject.setStyleMapStyleName(styleMapStyleName)\\n\\n # location\\n instanceLocation = self.locationFromElement(instanceElement)\\n\\n if instanceLocation is not None:\\n instanceObject.setLocation(instanceLocation)\\n\\n if makeGlyphs:\\n\\n # step 1: generate all glyphs we have mutators for.\\n names = instanceObject.getAvailableGlyphnames()\\n for n in names:\\n unicodes = self.unicodeMap.get(n, None)\\n try:\\n instanceObject.addGlyph(n, unicodes)\\n except AssertionError:\\n if self.verbose and self.logger:\\n self.logger.info(\\\"Problem making glyph %s, skipping.\\\", n)\\n # step 2: generate all the glyphs that have special definitions.\\n for glyphElement in instanceElement.findall('.glyphs/glyph'):\\n self.readGlyphElement(glyphElement, instanceObject)\\n\\n # read the kerning\\n if makeKerning:\\n for kerningElement in instanceElement.findall('.kerning'):\\n self.readKerningElement(kerningElement, instanceObject)\\n break\\n\\n # read the fontinfo\\n if makeInfo:\\n for infoElement in instanceElement.findall('.info'):\\n self.readInfoElement(infoElement, instanceObject)\\n\\n # copy the features\\n if self.featuresSource is not None:\\n instanceObject.copyFeatures(self.featuresSource)\\n\\n # copy the groups\\n if self.groupsSource is not None:\\n if self.groupsSource in self.sources:\\n groupSourceObject, loc = self.sources[self.groupsSource]\\n # copy the groups from the designated source to the new instance\\n # note: setGroups will filter the group members\\n # only glyphs present in the font will be added to the group.\\n # Depending on the ufoversion we might or might not expect the kerningGroupConversionRenameMaps attribute.\\n if hasattr(groupSourceObject, \\\"kerningGroupConversionRenameMaps\\\"):\\n renameMap = groupSourceObject.kerningGroupConversionRenameMaps\\n else:\\n renameMap = {}\\n instanceObject.setGroups(groupSourceObject.groups, kerningGroupConversionRenameMaps=renameMap)\\n\\n # lib items\\n if self.libSource is not None:\\n if self.libSource in self.sources:\\n libSourceObject, loc = self.sources[self.libSource]\\n instanceObject.setLib(libSourceObject.lib)\\n\\n # save the instance. Done.\\n success, report = instanceObject.save()\\n if not success and self.logger:\\n # report problems other than validation errors and failed glyphs\\n self.logger.info(\\\"%s:\\\\nErrors generating: %s\\\", filename, report)\\n\\n # report failed glyphs\\n failed = instanceObject.getFailed()\\n if failed:\\n failed.sort()\\n msg = \\\"%s:\\\\nErrors calculating %s glyphs: \\\\n%s\\\"%(filename, len(failed),\\\"\\\\t\\\"+\\\"\\\\n\\\\t\\\".join(failed))\\n self.reportProgress('error', 'glyphs', msg)\\n if self.verbose and self.logger:\\n self.logger.info(msg)\\n\\n # report missing unicodes\\n missing = instanceObject.getMissingUnicodes()\\n if missing:\\n missing.sort()\\n msg = \\\"%s:\\\\nPossibly missing unicodes for %s glyphs: \\\\n%s\\\"%(filename, len(missing),\\\"\\\\t\\\"+\\\"\\\\n\\\\t\\\".join(missing))\\n self.reportProgress('error', 'unicodes', msg)\\n\\n # store\\n self.instances[postScriptFontName] = instanceObject\\n self.reportProgress(\\\"generate\\\", 'stop', filenameTokenForResults)\",\n \"def get_serialization_instance(cls, value):\\n\\n # if the instance is a list, convert it to a cls instance.\\n # this is only useful when deserializing method arguments for a client\\n # request which is the only time when the member order is not arbitrary\\n # (as the members are declared and passed around as sequences of\\n # arguments, unlike dictionaries in a regular class definition).\\n if isinstance(value, list) or isinstance(value, tuple):\\n assert len(value) <= len(cls._type_info)\\n\\n cls_orig = cls\\n if cls.__orig__ is not None:\\n cls_orig = cls.__orig__\\n inst = cls_orig()\\n\\n keys = cls._type_info.keys()\\n for i in range(len(value)):\\n setattr(inst, keys[i], value[i])\\n\\n elif isinstance(value, dict):\\n inst = cls()\\n\\n for k in cls._type_info:\\n setattr(inst, k, value.get(k, None))\\n\\n else:\\n inst = value\\n\\n return inst\",\n \"def __init__(self, name=None, debug_mode=False, features=None, ui=None, is_default=False, created=None, modified=None, id=None, team_id=None, team=None, portals=None, product_groups=None, product_types=None, product_sizes=None, product_size_materials=None, product_size_materials_rel=None):\\n self.swagger_types = {\\n 'name': 'str',\\n 'debug_mode': 'bool',\\n 'features': 'object',\\n 'ui': 'object',\\n 'is_default': 'bool',\\n 'created': 'datetime',\\n 'modified': 'datetime',\\n 'id': 'str',\\n 'team_id': 'str',\\n 'team': 'Team',\\n 'portals': 'list[Portal]',\\n 'product_groups': 'list[ProductGroup]',\\n 'product_types': 'list[ProductType]',\\n 'product_sizes': 'list[ProductSize]',\\n 'product_size_materials': 'list[ProductSizeMaterial]',\\n 'product_size_materials_rel': 'list[TeamBuilderConfigProductSizeMaterial]'\\n }\\n\\n self.attribute_map = {\\n 'name': 'name',\\n 'debug_mode': 'debugMode',\\n 'features': 'features',\\n 'ui': 'ui',\\n 'is_default': 'isDefault',\\n 'created': 'created',\\n 'modified': 'modified',\\n 'id': 'id',\\n 'team_id': 'teamId',\\n 'team': 'team',\\n 'portals': 'portals',\\n 'product_groups': 'productGroups',\\n 'product_types': 'productTypes',\\n 'product_sizes': 'productSizes',\\n 'product_size_materials': 'productSizeMaterials',\\n 'product_size_materials_rel': 'productSizeMaterialsRel'\\n }\\n\\n self._name = name\\n self._debug_mode = debug_mode\\n self._features = features\\n self._ui = ui\\n self._is_default = is_default\\n self._created = created\\n self._modified = modified\\n self._id = id\\n self._team_id = team_id\\n self._team = team\\n self._portals = portals\\n self._product_groups = product_groups\\n self._product_types = product_types\\n self._product_sizes = product_sizes\\n self._product_size_materials = product_size_materials\\n self._product_size_materials_rel = product_size_materials_rel\",\n \"def create(cls, xml):\\n raise Exception('Not Implemented Yet')\",\n \"def __init__(self, *args, **kwargs):\\r\\n super(OWS, self).__init__(*args, **kwargs)\\r\\n\\r\\n self.query = {\\\"VERSION\\\": \\\"1.0.0\\\", \\\"REQUEST\\\": \\\"GetCapabilities\\\"}\\r\\n # Amended with \\\"SERVICE\\\" parameter by subclasses\\r\\n\\r\\n # If service or version parameters are left in query string, it can lead to a protocol error and false negative\\r\\n self.service_url = re.sub(r\\\"(?i)(version|service|request)=.*?(&|$)\\\", \\\"\\\", self.service_url)\\r\\n\\r\\n self.layer = self.layer.lower() if self.layer else None\\r\\n self.layer_elements = None\",\n \"def create_foundation_sdk_instance():\\n instance = LockedInstance(\\n lock=threading.Lock(),\\n instance=SDK(**(request.get_json() or {})),\\n module=None,\\n entity=SDK_ENTITY_NAME,\\n uuid=str(uuid.uuid4().hex),\\n created_at=datetime.datetime.utcnow(),\\n )\\n STORE[instance.uuid] = instance\\n response = app.response_class(\\n response=json.dumps(serialise_instance(instance)),\\n status=201,\\n mimetype='application/json'\\n )\\n return response\",\n \"def from_xml(cls, xml_data, system, id_generator):\\r\\n raise NotImplementedError('Modules must implement from_xml to be parsable from xml')\",\n \"def create_service_instance(self, serviceManufacturer, serviceType) -> Union[UpnpServiceProxy, None]:\\n serviceInst = None\\n if serviceType is not None:\\n extkey = generate_extension_key(serviceManufacturer, serviceType)\\n if extkey in self._service_registry:\\n serviceClass = self._service_registry[extkey]\\n serviceInst = serviceClass()\\n return serviceInst\",\n \"def __init__(self, **kwargs):\\n with KWArgs(kwargs) as k:\\n metadata = k.optional(\\\"metadata\\\")\\n\\n self._ax = ca.boolean()\\n self.metadata = metadata\"\n]"},"negative_scores":{"kind":"list like","value":["0.5577236","0.5367035","0.5321477","0.5150564","0.50830454","0.5067312","0.4986971","0.49749762","0.4935389","0.48817945","0.4843432","0.48354465","0.48144224","0.47744632","0.47571477","0.47335753","0.47333562","0.47290888","0.47188824","0.46990353","0.46851358","0.4661856","0.46545747","0.4653167","0.46447936","0.46366242","0.46229136","0.4611534","0.45930302","0.45751363","0.45721653","0.4568326","0.45665586","0.45643023","0.45603958","0.45551097","0.45549124","0.45527393","0.45511377","0.454809","0.45466587","0.4541401","0.4528824","0.45241785","0.45232117","0.4512391","0.4512391","0.44884825","0.44836727","0.44669187","0.44640434","0.4463944","0.44630235","0.44497624","0.4445383","0.4444116","0.4437977","0.4432881","0.44288945","0.4421241","0.44199684","0.4417163","0.44122428","0.4408873","0.44018352","0.4401643","0.43859872","0.4380369","0.4373761","0.43577474","0.43551284","0.43491828","0.43488842","0.4344803","0.4335016","0.43249065","0.43232444","0.43219897","0.4321757","0.43200162","0.43187308","0.43151832","0.4314413","0.4313697","0.43102914","0.43095985","0.43034405","0.42970973","0.4297028","0.4296706","0.42934772","0.42891452","0.42884478","0.42837813","0.4279225","0.42708585","0.4262313","0.42596236","0.42594934","0.42594898"],"string":"[\n \"0.5577236\",\n \"0.5367035\",\n \"0.5321477\",\n \"0.5150564\",\n \"0.50830454\",\n \"0.5067312\",\n \"0.4986971\",\n \"0.49749762\",\n \"0.4935389\",\n \"0.48817945\",\n \"0.4843432\",\n \"0.48354465\",\n \"0.48144224\",\n \"0.47744632\",\n \"0.47571477\",\n \"0.47335753\",\n \"0.47333562\",\n \"0.47290888\",\n \"0.47188824\",\n \"0.46990353\",\n \"0.46851358\",\n \"0.4661856\",\n \"0.46545747\",\n \"0.4653167\",\n \"0.46447936\",\n \"0.46366242\",\n \"0.46229136\",\n \"0.4611534\",\n \"0.45930302\",\n \"0.45751363\",\n \"0.45721653\",\n \"0.4568326\",\n \"0.45665586\",\n \"0.45643023\",\n \"0.45603958\",\n \"0.45551097\",\n \"0.45549124\",\n \"0.45527393\",\n \"0.45511377\",\n \"0.454809\",\n \"0.45466587\",\n \"0.4541401\",\n \"0.4528824\",\n \"0.45241785\",\n \"0.45232117\",\n \"0.4512391\",\n \"0.4512391\",\n \"0.44884825\",\n \"0.44836727\",\n \"0.44669187\",\n \"0.44640434\",\n \"0.4463944\",\n \"0.44630235\",\n \"0.44497624\",\n \"0.4445383\",\n \"0.4444116\",\n \"0.4437977\",\n \"0.4432881\",\n \"0.44288945\",\n \"0.4421241\",\n \"0.44199684\",\n \"0.4417163\",\n \"0.44122428\",\n \"0.4408873\",\n \"0.44018352\",\n \"0.4401643\",\n \"0.43859872\",\n \"0.4380369\",\n \"0.4373761\",\n \"0.43577474\",\n \"0.43551284\",\n \"0.43491828\",\n \"0.43488842\",\n \"0.4344803\",\n \"0.4335016\",\n \"0.43249065\",\n \"0.43232444\",\n \"0.43219897\",\n \"0.4321757\",\n \"0.43200162\",\n \"0.43187308\",\n \"0.43151832\",\n \"0.4314413\",\n \"0.4313697\",\n \"0.43102914\",\n \"0.43095985\",\n \"0.43034405\",\n \"0.42970973\",\n \"0.4297028\",\n \"0.4296706\",\n \"0.42934772\",\n \"0.42891452\",\n \"0.42884478\",\n \"0.42837813\",\n \"0.4279225\",\n \"0.42708585\",\n \"0.4262313\",\n \"0.42596236\",\n \"0.42594934\",\n \"0.42594898\"\n]"},"document_score":{"kind":"string","value":"0.54205626"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":1695,"cells":{"query":{"kind":"string","value":"Call the named remote web service method."},"document":{"kind":"string","value":"def _call(self, name, *args, **kwargs):\r\n if len(args) and len(kwargs):\r\n raise TypeError(\r\n 'Use positional or keyword argument only.'\r\n )\r\n\r\n callinfo = getattr(self, name).callinfo\r\n soapAction = callinfo.soapAction\r\n url = callinfo.location\r\n (protocol, host, uri, query, fragment, identifier) = urlparse(url)\r\n port = '80'\r\n if host.find(':') >= 0:\r\n host, port = host.split(':')\r\n\r\n binding = Binding(host=host, tracefile=self._tracefile,\r\n ssl=(protocol == 'https'),\r\n port=port, url=None, typesmodule=self._typesmodule,\r\n nsdict=self._nsdict, soapaction=self._soapAction,\r\n ns=self._ns, op_ns=self._op_ns)\r\n\r\n if self._use_wsdl:\r\n request, response = self._getTypeCodes(callinfo)\r\n if len(kwargs): args = kwargs\r\n if request is None:\r\n request = Any(oname=name)\r\n binding.Send(url=uri, opname=None, obj=args,\r\n nsdict=self._nsdict, soapaction=soapAction, requesttypecode=request)\r\n return binding.Receive(replytype=response)\r\n\r\n apply(getattr(binding, callinfo.methodName), args)\r\n\r\n return binding.Receive()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _call(self, rpc_method_name, *args, **kwargs):\n method = getattr(self, rpc_method_name)\n return method(*args, **kwargs)","def _method_call(self, msg):\n #print(\"Performing service: %s, method_name: %s\" % (msg.service_name, msg.method_name))\n service = self._services.get(msg.service_name)\n if service is None:\n raise MessageHandleError(MessageHandleError.RESULT_UNKNOWN_SERVICE, msg)\n\n try:\n return execute_remote_method_call(service, msg.method_name, *msg.pargs, **msg.kwargs)\n #return service.call(msg.method_name, *msg.pargs, **msg.kwargs)\n except MessageHandleError as error:\n error.original_message = msg\n raise error","def callRemote(self, methname, *args, **kwargs):\n schema = self._referenceable.getInterface()[methname]\n if self.check_args:\n schema.checkAllArgs(args, kwargs, inbound=False)\n # TODO: Figure out how to call checkResults on the result.\n return execute(\n self._referenceable.doRemoteCall,\n methname,\n args,\n kwargs,\n )","def callRemote(self, methname, *args, **kwargs):\n try:\n schema = self._referenceable.getInterface()[methname]\n if self.check_args:\n schema.checkAllArgs(args, kwargs, inbound=True)\n _check_copyables(list(args) + kwargs.values())\n result = self._referenceable.doRemoteCall(\n methname,\n args,\n kwargs,\n )\n schema.checkResults(result, inbound=False)\n _check_copyables([result])\n return succeed(result)\n except:\n return fail()","def call(self, method, name, params=None, payload=None, **kwds):","def callRemote(self, name, *args, **kw):\n if hasattr(self, 'sync_'+name):\n return getattr(self, 'sync_'+name)(*args, **kw)\n try:\n method = getattr(self, \"async_\" + name)\n return defer.succeed(method(*args, **kw))\n except:\n f = Failure()\n if self.reportAllTracebacks:\n f.printTraceback()\n return defer.fail(f)","def export_callProxyMethod( self, name, args, kargs ):\n res = pythonCall( 120, self.__proxyWrapper, name, args, kargs )\n if res['OK']:\n return res['Value']\n else:\n return res","def execute(self, methodname, *args):\n if not methodname in self.methods:\n raise BlogError(BlogError.METHOD_NOT_SUPPORTED)\n\n try:\n r = getattr(self.server, methodname)(args)\n except xmlrpclib.Fault, fault:\n raise BlogError(fault.faultString)\n\n return r","def call(self, name, *args, **kwargs):\r\n return self.client.call(self.name, name, *args, **kwargs)","def __executeOperation( self, url, method ):\n fcn = None\n if hasattr( self, method ) and callable( getattr( self, method ) ):\n fcn = getattr( self, method )\n if not fcn:\n return S_ERROR( \"Unable to invoke %s, it isn't a member function of DIPStorage\" % method )\n\n res = fcn( url )\n if not res['OK']:\n return res\n elif url not in res['Value']['Successful']:\n return S_ERROR( res['Value']['Failed'][url] )\n\n return S_OK( res['Value']['Successful'][url] )","def remote(self, method, params=()):\n\n response = self.transport.request(self.host, \n '/RPC2',\n dumps(params, method))\n return response","def call(self, method, *args, **kwargs):\n if method in self.handlers:\n handler = self.handlers[method]\n if self.single_server:\n self.send_request(self.single_server, method, handler, *args, **kwargs)\n else:\n if method in [\"completion\", \"completion_item_resolve\", \"diagnostics\", \"code_action\", \"execute_command\"]:\n method_server_names = self.multi_servers_info[method]\n else:\n method_server_names = [self.multi_servers_info[method]]\n\n for method_server_name in method_server_names:\n method_server = self.multi_servers[method_server_name]\n self.send_request(method_server, method, handler, *args, **kwargs)\n elif hasattr(self, method):\n getattr(self, method)(*args, **kwargs)","def call(self, obj_name, method_name, param_dict=dict()):\n result = self.ctrl_client.call(obj_name, method_name, param_dict)\n if result['type'] == 'error':\n self.logger.error(\"API call error: {}\".format(result['msg']))\n return None\n else:\n return result['call_return']","def _call_method(self, module, method, *args, **kwargs):\n return self.invoke_api(module, method, *args, **kwargs)","def __call__(self):\n params, method = parse_xmlrpc_request(self.request)\n return xmlrpc_response(getattr(self,method)(*params))","def callRemote(self, _name, *args, **kw):\r\n if self.__failure is not None:\r\n d = fail(self.__failure)\r\n elif self.__pending is not None:\r\n d = Deferred()\r\n self.__pending.append(d)\r\n else:\r\n d = succeed(self.__obj)\r\n\r\n d.addCallback(lambda ref: ref.callRemote(_name, *args, **kw))\r\n d.addErrback(self.__filter, _name)\r\n return d","def _remote_call(self,\n method_name,\n target='Widget',\n args=None,\n kwargs=None):\n args = [] if args is None else args\n kwargs = {} if kwargs is None else kwargs\n\n msg = {}\n\n if 'component_index' in kwargs:\n msg['component_index'] = kwargs.pop('component_index')\n if 'repr_index' in kwargs:\n msg['repr_index'] = kwargs.pop('repr_index')\n\n msg['target'] = target\n msg['type'] = 'call_method'\n msg['methodName'] = method_name\n msg['args'] = args\n msg['kwargs'] = kwargs\n\n def callback(widget, msg=msg):\n widget.send(msg)\n\n callback._method_name = method_name\n callback._ngl_msg = msg\n\n if self.loaded:\n self._remote_call_thread.q.append(callback)\n else:\n # send later\n # all callbacks will be called right after widget is loaded\n self._ngl_displayed_callbacks_before_loaded.append(callback)\n\n if callback._method_name not in _EXCLUDED_CALLBACK_AFTER_FIRING:\n self._ngl_displayed_callbacks_after_loaded.append(callback)","def _execApiCall(headers, params, method_name,\r\n domain='ma.gnolia.com',\r\n urlhead='/api/rest/1/'):\r\n \r\n if 'api_key' not in params and method_name not in ['echo', 'get_key']:\r\n raise MagnoliaException('Required API Key parameter missing')\r\n conn = httplib.HTTPConnection(domain)\r\n conn.request('POST', urlhead + method_name, params, headers)\r\n return conn.getresponse()","def __getattr__(self, method):\n def run_callback(func, plus, result):\n \"\"\"Execute the given callback safely.\n Get data and/or error from result and call func passing it\n data, plus (if needed) and error. Catch, log and suppress\n all exceptions.\n func (function): the callback to invoke.\n plus (object): optional additional data.\n result (AsyncResult): the result of a (finished) RPC call.\n \"\"\"\n data = result.value\n error = None if result.successful() else \"%s\" % result.exception\n try:\n if plus is None:\n func(data, error=error)\n else:\n func(data, plus, error=error)\n except Exception as error:\n logger.error(\"RPC callback for %s.%s raised exception.\",\n self.remote_service_coord.name, method,\n exc_info=True)\n\n def remote_method(**data):\n \"\"\"Forward arguments to execute_rpc.\n \"\"\"\n callback = data.pop(\"callback\", None)\n plus = data.pop(\"plus\", None)\n result = self.execute_rpc(method=method, data=data)\n if callback is not None:\n callback = functools.partial(run_callback, callback, plus)\n result.rawlink(functools.partial(gevent.spawn, callback))\n return result\n\n return remote_method","def call(self, uri, method, arg, extras):\n pass","def do_rpc(self, method, **params):\n data = {\n 'jsonrpc': '2.0',\n 'method': method,\n 'params': params,\n 'authorization': self._auth_token,\n 'id': '1'\n }\n\n r = requests.post(self._url, json=data)\n validate_response(r)\n\n return r.json()['result']","def call(self, port, method, *args, **kwargs):\n method = self.provides[port][method]\n return method(*args, **kwargs)","def xen_rpc_call(ip, method, *args):\n try:\n if not ip:\n return xen_api_error(\"Invalid ip for rpc call\")\n # create\n proxy = ServerProxy(\"http://\" + ip + \":9363/\")\n \n # login \n response = proxy.session.login('root')\n if cmp(response['Status'], 'Failure') == 0:\n log.exception(response['ErrorDescription'])\n return xen_api_error(response['ErrorDescription']) \n session_ref = response['Value']\n \n # excute\n method_parts = method.split('_')\n method_class = method_parts[0]\n method_name = '_'.join(method_parts[1:])\n \n if method.find(\"host_metrics\") == 0:\n method_class = \"host_metrics\"\n method_name = '_'.join(method_parts[2:])\n #log.debug(method_class)\n #log.debug(method_name)\n if method_class.find(\"Async\") == 0:\n method_class = method_class.split(\".\")[1]\n response = proxy.__getattr__(\"Async\").__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\n else:\n response = proxy.__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\n if cmp(response['Status'], 'Failure') == 0:\n log.exception(response['ErrorDescription'])\n return xen_api_error(response['ErrorDescription'])\n # result\n return response\n except socket.error:\n return xen_api_error('socket error')","def call(self, method=None, args=[]):\n\n client = xmlclient.ServerProxy(uri=self.api_endpoint, encoding='utf-8',\n allow_none=True)\n response = getattr(client, method)(self.username, self.password, *args)\n if response == 'OK':\n return True\n elif 'AUTH_ERROR' in response:\n raise AuthError()\n elif response == 'DOMAIN_OCCUPIED':\n raise DomainOccupiedError()\n elif response == 'RATE_LIMITED':\n raise RateLimitedError()\n elif response == 'BAD_INDATA':\n raise BadInDataError()\n elif response == 'UNKNOWN_ERROR':\n raise UnknownError()\n else:\n return response","def _dispatch(self, method, params):\n logging.debug('Calling %s%s', method, params)\n self._rpc_received_event.set()\n return SimpleJSONRPCServer.SimpleJSONRPCServer._dispatch(\n self, method, params)","def call_rpc(rpc_user, rpc_pwd, method):\n base_url = 'http://127.0.0.1:37128/'\n try:\n response = post(base_url,\n data=method,\n auth=(rpc_user, rpc_pwd)\n )\n except Exception as e:\n response = e\n return evaluate_response(response)","def __call__(self, **action_kwargs):\n\n return SOAP.send(self.service, self, **action_kwargs)","def call_selenium_api(self, method_name, *args):\n try:\n method = getattr(self._selenium, method_name)\n except AttributeError:\n method = lambda *args: self._selenium.do_command(method_name, args)\n return method(*args)","def api_call(self, method, host, params):\n session_id = self.rpc_login(host)\n params.insert(0, session_id)\n json_rpc_request = {\n 'jsonrpc': '2.0',\n 'method': method,\n 'params': params,\n 'id': self.ID\n }\n\n self.ID += 1\n response = requests.post(host, data=json.dumps(json_rpc_request), headers=self.headers)\n\n return response","def send_method_call(self, service_name, method_name, *pargs, **kwargs):\n msg = MethodCallMessage(service_name=service_name, method_name=method_name, pargs=pargs, kwargs=kwargs)\n return self.send_message_blocking(msg)","def remote_method(**data):\n callback = data.pop(\"callback\", None)\n plus = data.pop(\"plus\", None)\n result = self.execute_rpc(method=method, data=data)\n if callback is not None:\n callback = functools.partial(run_callback, callback, plus)\n result.rawlink(functools.partial(gevent.spawn, callback))\n return result","def call_method(self, request, context):\n response = CallMethodResponse()\n args = []\n for arg in request.args:\n args.append(decode(arg))\n if args != []:\n result = \\\n self._delegator.call_method(\n request.component, request.method, *args)\n else:\n result = \\\n self._delegator.call_method(\n request.component, request.method, None)\n response.result = encode(result)\n return response","def make_call(self, method, _):\n raise CallNotFound('{}.{} does not exist'.format(self.service_name,\n method))","def xmlrpc_methods():","def make_xml_rpc_api_call(uri, method, args=None, headers=None,\r\n http_headers=None, timeout=None, proxy=None):\r\n if args is None:\r\n args = tuple()\r\n try:\r\n largs = list(args)\r\n largs.insert(0, {'headers': headers})\r\n\r\n payload = xmlrpc_client.dumps(tuple(largs),\r\n methodname=method,\r\n allow_none=True)\r\n session = requests.Session()\r\n req = requests.Request('POST', uri, data=payload,\r\n headers=http_headers).prepare()\r\n LOGGER.debug(\"=== REQUEST ===\")\r\n LOGGER.info('POST %s', uri)\r\n LOGGER.debug(req.headers)\r\n LOGGER.debug(payload)\r\n\r\n response = session.send(req,\r\n timeout=timeout,\r\n proxies=_proxies_dict(proxy))\r\n LOGGER.debug(\"=== RESPONSE ===\")\r\n LOGGER.debug(response.headers)\r\n LOGGER.debug(response.content)\r\n response.raise_for_status()\r\n result = xmlrpc_client.loads(response.content,)[0][0]\r\n return result\r\n except xmlrpc_client.Fault as ex:\r\n # These exceptions are formed from the XML-RPC spec\r\n # http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php\r\n error_mapping = {\r\n '-32700': NotWellFormed,\r\n '-32701': UnsupportedEncoding,\r\n '-32702': InvalidCharacter,\r\n '-32600': SpecViolation,\r\n '-32601': MethodNotFound,\r\n '-32602': InvalidMethodParameters,\r\n '-32603': InternalError,\r\n '-32500': ApplicationError,\r\n '-32400': RemoteSystemError,\r\n '-32300': TransportError,\r\n }\r\n raise error_mapping.get(ex.faultCode, SoftLayerAPIError)(\r\n ex.faultCode, ex.faultString)\r\n except requests.HTTPError as ex:\r\n raise TransportError(ex.response.status_code, str(ex))\r\n except requests.RequestException as ex:\r\n raise TransportError(0, str(ex))","def get_method(self, name):\n try:\n return self.methods[name]\n except KeyError:\n raise ServiceException('Service method \"%s\" not registered' % name)","def call_method(self, name, method, params):\n self.logger.debug(\"API call: {}.{}({})\".format(name, method, params))\n if name in self.systems:\n obj = self.systems[name]\n if is_api_method(obj, method):\n try:\n # Calls given obj.method, unpacking and passing params dict\n call_return = getattr(obj, method)(**params)\n msg = \"Called {}.{}\".format(name, method)\n self.logger.debug(msg + \",returned:{}\".format(call_return))\n return msgs.call_reply(msg, call_return)\n except TypeError:\n # Raised when we have a mismatch of the method's kwargs\n # TODO: Return argspec here?\n err_msg = \"Invalid params for {}.{}\".format(name, method)\n self.logger.warning(err_msg)\n return msgs.error(err_msg)\n except Exception as e:\n # Catch exception raised by called method, notify client\n err_msg = \"Exception: '{}'\".format(str(e))\n self.logger.warning(err_msg)\n return msgs.error(err_msg)\n else:\n err_msg = \"Invalid method: '{}.{}'\".format(name, method)\n self.logger.warning(err_msg)\n return msgs.error(err_msg)\n else:\n err_msg = \"Invalid object: '{}'\".format(name)\n self.logger.warning(err_msg)\n return msgs.error(err_msg)","def call(self, name, request=None, **params):\r\n if not name in self.resources:\r\n raise exceptions.HttpError('Unknown method \\'%s\\'' % name,\r\n status=status.HTTP_501_NOT_IMPLEMENTED)\r\n request = request or HttpRequest()\r\n resource = self.resources[name]\r\n view = resource.as_view(api=self)\r\n return view(request, **params)","def call_method(self, action):\n\n\t\tif action[0] in self.methods:\n\t\t\tself.methods[action[0]](action[0:])\n\t\telse:\n\t\t\tself.no_such_method()","def _execute_impl(self, *args, **kwargs):\n # Execute with bound args.\n method_body = getattr(self._deployment_node, self._deployment_method_name)\n return method_body.remote(\n *self._bound_args,\n **self._bound_kwargs,\n )","def __call__(self, method, *args, **kwargs):\n if hasattr(self, 'channel'):\n kwargs.setdefault('channel', self.channel)\n resp = self._client.api_call(method, *args, **kwargs)\n if not resp['ok']:\n print unicode(resp)\n raise RuntimeError(resp.get('error', unicode(resp)))\n return resp","def rpc_call(self, request, method=None, params=None, **kwargs):\r\n args = []\r\n kwargs = dict()\r\n if isinstance(params, dict):\r\n kwargs.update(params)\r\n else:\r\n args = list(as_tuple(params))\r\n\r\n method_key = \"{0}.{1}\".format(self.scheme_name, method)\r\n if method_key not in self.methods:\r\n raise AssertionError(\"Unknown method: {0}\".format(method))\r\n method = self.methods[method_key]\r\n\r\n if hasattr(method, 'request'):\r\n args.insert(0, request)\r\n\r\n return method(*args, **kwargs)","def call(self, **kwargs):\n return getattr(self.resource, self.function)(**kwargs)","def _ExecuteRequest(request):\n service = request.service_name()\n method = request.method()\n service_methods = remote_api_services.SERVICE_PB_MAP.get(service, {})\n request_class, response_class = service_methods.get(method, (None, None))\n if not request_class:\n raise apiproxy_errors.CallNotFoundError('%s.%s does not exist' % (service,\n method))\n\n request_data = request_class()\n request_data.ParseFromString(request.request())\n response_data = response_class()\n\n def MakeRequest():\n apiproxy_stub_map.MakeSyncCall(service, method, request_data,\n response_data)\n\n\n\n if service in THREAD_SAFE_SERVICES:\n MakeRequest()\n else:\n with GLOBAL_API_LOCK:\n MakeRequest()\n return response_data","def\trunMethod(self, name = \"__default\", prms = {}):\n\n\t\tprms = self.CSLBuildPrmList(prms)\n\t\tlocalTbl = { 'vars':{}, 'status':0, 'props':{}, 'alias':{}, 'persistent':{}, 'instance':{}}\n\n\t\tres = self.callMethod(name, prms, localTbl)\n\n\t\tif localTbl[\"status\"] == 2:\n\t\t\treturn self.COMARValue.COMARRetVal(1, None)\n\t\telse:\t\t\t\n\t\t\tret = self.CSLtoCOMARValue(res)\n\t\t\tself.debug(DEBUG_FATAL, \"RETS:\", res, '(%s)->' % (res.type), ret)\n\t\t\treturn self.COMARValue.COMARRetVal(0, ret)","def ServiceMethod(fn):\n\n fn.IsServiceMethod = True\n return fn","def client_member_function(self, method: ProtoServiceMethod) -> None:","def rpc_request(method, params, url=LOCAL):\n client = HTTPClient(url)\n return client.request(method, params)","def call(self, method, *args):\n flatcall = flatten(\n m(n=method, t=self.groupName)[[\n squish(x) for x in args if x is not None]])\n self.socket.write(flatcall + '\\0')","def call_method(self, method_name: str, timeout=None, **params) -> dict:\n timeout = timeout or self.timeout\n request_id = uuid.uuid4().hex\n data = {'@type': method_name,\n '@extra': {'request_id': request_id}}\n data.update(params)\n self._tdjson_client.send(data)\n\n result = self._wait_result(request_id, timeout)\n return result","def execute_rpc(self, method, data):\n result = gevent.event.AsyncResult()\n result.set_exception(\n RPCError(\"Called a method of a non-configured service.\"))\n return result","def rpc_call(self, ctx, rpc_request):\n rpc_method = rpc_request['method']\n start_time = time.time()\n try:\n return self._rpc_call([ctx.proxyfsd_addrinfo], rpc_request)\n finally:\n duration = time.time() - start_time\n self.logger.debug(\"RPC %s took %.6fs\", rpc_method, duration)","def __call__(self, method, url, *args, **kwargs):\n log.debug('{} {}'.format(method.upper(), url))\n if 'params' in kwargs:\n kwargs['query'] = kwargs.pop('params')\n return getattr(self.client, method)(url, *args, **kwargs).json","def call(self, method, **kwargs):\n response = self._do_request(method, **kwargs)\n return self._deserialize_response(response)","def call(self, command, *args, **kwargs):\n\n\tif command in self.command_table:\n\t cmdopts = self.command_table[command]\n\t function = cmdopts.get('function', None)\n\t method = cmdopts.get('method', None)\n\t template = cmdopts.get('url_template', None)\n\t retval = function(method, template, *args, **kwargs)\n\t if not retval:\n\t\traise RuntimeError, 'request returned no data'\n\t return retval\n\telse:\n\t raise RuntimeError, 'unknown command: %s' % command","def _platformix_call(self, context, fake_reply, method, *args, **kwargs):\r\n if hasattr(self.host, method):\r\n if not callable(getattr(self.host, method)):\r\n self._reply(context, proto_failure(\"Attribute {} of {} is a property\".format(\r\n property, self.host.name)), fake_reply)\r\n return\r\n try:\r\n result = getattr(self.host, method)(*args, **kwargs)\r\n except Exception as e:\r\n eprint(\"Platformix protocol: failed to call method {} of {} with args {}, kwargs {} \"\r\n \"due to exception {}\".format(method, self.host.name, args, kwargs, e))\r\n exprint()\r\n self._reply(context, proto_failure(\r\n \"Failed to call method {} of {} with args {}, kwargs {} \"\r\n \"due to exception {}\".format(method, self.host.name, args, kwargs, e)), fake_reply)\r\n return\r\n self._reply(context, proto_success(result), fake_reply)\r\n else:\r\n self._reply(context, proto_failure(\"Method {} not found on {}\".format(property, self.host.name)),\r\n fake_reply)","def call_async(self, name, *args, **kwargs):","def __call__(self, *args, **kwargs):\n return self.method(*args, **kwargs)","def _invokeMember(obj, memberName, *args, **kwargs):\n return getattr(obj, memberName)(*args, **kwargs)","def exec_method(self, module_name, version=None, client_class=None,\n method_name=None, *args, **kwargs):\n client_class = client_class or 'Client'\n client_version = version or 2\n _client = self.create_client(module_name, client_version,\n client_class)\n try:\n # NOTE(kiennt): method_name could be a combination\n # for example 'servers.list'. Here is the\n # workaround.\n method = getattr(_client, method_name.split('.')[0])\n for attr in method_name.split('.')[1:]:\n method = getattr(method, attr)\n return method(*args, **kwargs)\n except Exception as err:\n raise err","def __getattr__(self, method_name):\n return partial(self.exec, method_name.replace(\"_\", \" \"))","def rpcmethod(func):\n func.rpcmethod = True\n return func","def _api_call(self, method, resource, **kwargs):\n uri = \"/%s?%s&username=%s\" % (resource, urlencode(kwargs), self.username)\n print (uri)\n c = self.get_connection()\n c.request(method, uri)\n response = c.getresponse()\n if not 200 == response.status:\n raise GeoNameException(\"Expected a 200 reponse but got %s.\" % (response.status))\n return self.response_handler.get_processed_data(response.read())","def call_service(func, api_kwargs, context, request):\n pattern = request.matched_route.pattern\n service = request.registry['soap_services'].get(pattern)\n request.META = request.headers.environ # to be used by soapbox, like django\n request.service = service\n\n SOAP = service.version\n\n if request.method == 'GET' and 'wsdl' in request.params:\n tree = py2wsdl.generate_wsdl(request.service)\n body = etree.tostring(tree, pretty_print=True)\n return Response(body=body, content_type=SOAP.CONTENT_TYPE)\n\n try:\n xml = request.body\n envelope = SOAP.Envelope.parsexml(xml)\n message = envelope.Body.content()\n soap_action = SOAP.determin_soap_action(request)\n tagname, return_object = call_the_method(service,\n request, message, soap_action)\n soap_message = SOAP.Envelope.response(tagname, return_object)\n return Response(body=soap_message, content_type=SOAP.CONTENT_TYPE)\n except (ValueError, etree.XMLSyntaxError) as e:\n response = SOAP.get_error_response(SOAP.Code.CLIENT, str(e))\n except Exception, e:\n response = SOAP.get_error_response(SOAP.Code.SERVER, str(e))\n return Response(body=response, content_type=SOAP.CONTENT_TYPE)","def invoke_method(self, method, uri, query_param={}, request_param={}, headers=None, **kwargs):\n query_param.setdefault(\"apiKey\", self.api_key)\n\n method = method.lower()\n\n if method == \"get\":\n resp = self.get(method, uri, query_param, request_param, headers, **kwargs)\n\n elif method == \"post\":\n resp = self.post(method, uri, query_param, request_param, headers, **kwargs)\n\n elif method == \"delete\":\n resp = self.delete(method, uri, query_param, request_param, headers, **kwargs)\n\n elif method == \"patch\":\n resp = self.patch(method, uri, query_param, request_param, headers, **kwargs)\n\n else:\n raise BacklogError(\"Not supported http method: {}\".format(method))\n\n return resp","def _call(self, method, url, params):\n if not url.startswith('http'):\n url = self.root + url\n headers = self._auth_headers()\n headers['Content-Type'] = 'application/json'\n\n r = self._session.request(method, url,\n headers=headers,\n proxies=self.proxies,\n params=params,\n timeout=self.requests_timeout)\n r.raise_for_status() # Check for error\n return r.json()","def on_action(self, message):\n with self.handler.wrapee as wrapee:\n log.debug(\"Calling {method} on {name}\", method=message['action'], name=self.name)\n try:\n func = getattr(wrapee, message['action'])\n except AttributeError as ex:\n log.warn(\"Trying to call a method {method} that does not exsist!\",\n method=ex.args[0])\n return\n res, msg = func(*message['args'])\n if not res:\n log.warn(\"Error while calling {method}: {msg}\", msg=msg,\n method=message['action'])\n else:\n log.debug(\"Called method succesfully\")\n for protocol in self.service.protocols:\n protocol.send_packet()\n if msg != '':\n protocol.send_news(msg)","def callmethod(\n self, method: str, *args: Sequence[Any], **kwargs: Sequence[Any]\n ) -> List[Any]:\n return getattr(self, method)(*args, **kwargs)","def proxy_method(self, rest_path, sign, kwargs):","def _exe(self, method):\n request_path = self.request.path\n path = request_path.split('/')\n services_and_params = list(filter(lambda x: x!='',path))\n\n # Get all function names configured in the class RestHandler\n functions = list(filter(lambda op: hasattr(getattr(self,op),'_service_name') == True and inspect.ismethod(getattr(self,op)) == True, dir(self)))\n # Get all http methods configured in the class RestHandler\n http_methods = list(map(lambda op: getattr(getattr(self,op),'_method'), functions))\n\n if method not in http_methods:\n raise tornado.web.HTTPError(405,'The service not have %s verb' % method)\n for operation in list(map(lambda op: getattr(self,op), functions)):\n service_name = getattr(operation,\"_service_name\")\n service_params = getattr(operation,\"_service_params\")\n # If the _types is not specified, assumes str types for the params\n services_from_request = list(filter(lambda x: x in path,service_name))\n\n if operation._method == self.request.method and service_name == services_from_request and len(service_params) + len(service_name) == len(services_and_params):\n try:\n params_values = self._find_params_value_of_url(service_name,request_path) + self._find_params_value_of_arguments(operation)\n p_values = self._convert_params_values(params_values)\n body = str(self.request.body,'utf-8')\n self.request_data = None\n if body:\n self.request_data = json.loads(body)\n response = operation(*p_values)\n self.request_data = None\n\n if response == None:\n return\n\n self.set_header(\"Content-Type\",'application/json')\n self.write(json.dumps(response))\n self.finish()\n except Exception as detail:\n self.request_data = None\n self.gen_http_error(500,\"Internal Server Error : %s\"%detail)\n raise","def __call__(self, *args, **params):\n\t\treturn self.send(params)","def _dispatch(self, method, params):\n func = None\n try:\n # check to see if a matching function has been registered\n func = self.server.funcs[method]\n except KeyError:\n if self.server.instance is not None:\n # check for a _dispatch method\n if hasattr(self.server.instance, '_dispatch'):\n return self.server.instance._dispatch(method, params)\n else:\n # call instance method directly\n try:\n func = resolve_dotted_attribute(\n self.server.instance,\n method,\n self.server.allow_dotted_names\n )\n except AttributeError:\n pass\n\n request = Request(\n client_address=self.client_address,\n headers=self.headers,\n )\n if func is not None:\n return func(request, *params)\n else:\n raise Exception('method \"%s\" is not supported' % method)","def _call_it(params): # pragma: no cover\n instance, name, args = params\n kwargs = {}\n return getattr(instance, name)(*args, **kwargs)","def _call_method(self, method, req, resp_class):\n payload = req.SerializeToString()\n headers = {\n 'Content-Type': 'application/x-protobuf',\n 'Content-Length': str(len(payload))\n }\n response, content = self._http.request(\n self._url + method, method='POST', body=payload, headers=headers)\n if response.status != 200:\n raise RPCError(method, response, content)\n resp = resp_class()\n resp.ParseFromString(content)\n return resp","def _ServerProxy__request(self, methodname, params):\n\n paddedHandler = self._ServerProxy__handler\n\n # add on the methodName\n sep = '&'\n if '?' not in paddedHandler:\n sep = '?'\n paddedHandler = paddedHandler + \"%smethod=%s\" % (sep, methodname)\n sep = '&'\n\n # add on the auth token\n if self._authToken:\n paddedHandler = paddedHandler + \"%sauth_token=%s\" % (sep, urllib.quote_plus(self._authToken))\n\n # add on the partnerId\n if self._partnerId:\n paddedHandler = paddedHandler + \"%spartner_id=%s\" % (sep, self._partnerId)\n\n # add on the userId\n if self._userId:\n paddedHandler = paddedHandler + \"%suser_id=%s\" % (sep, self._userId)\n\n EXCLUDED_PAYLOAD_CALLS = ([\n \"auth.partnerLogin\",\n \"test.\",\n \"debug.\",\n \"testability.\"\n ])\n encryptRequest = True\n if self._requestCipher:\n for excludedMethodPattern in EXCLUDED_PAYLOAD_CALLS:\n if methodname.startswith(excludedMethodPattern):\n encryptRequest = False\n break\n else:\n encryptRequest = False\n\n # add the syncTime request\n if encryptRequest and self._sync:\n server_value, sync_time = self._sync\n params[0]['syncTime'] = server_value + int(time.time()) - sync_time\n\n request = xmlrpclib.dumps(params, methodname,\n encoding=self._ServerProxy__encoding,\n allow_none=self._ServerProxy__allow_none)\n\n #print \"------- XML REQUEST --------\"\n #print request\n\n if encryptRequest:\n request = self.encodeRequest(request)\n\n if self.x509:\n response = self._ServerProxy__transport.request(\n (self._ServerProxy__host, self.x509),\n paddedHandler,\n request,\n verbose=self._ServerProxy__verbose\n )\n else:\n response = self._ServerProxy__transport.request(\n self._ServerProxy__host,\n paddedHandler,\n request,\n verbose=self._ServerProxy__verbose\n )\n\n if len(response) == 1:\n response = response[0]\n\n #print \"------ RESPONSE ------\"\n #print response\n\n return response","def rpc_call(self, method: str, params: Optional[list] = None) -> Any:\r\n if params is None:\r\n params = []\r\n data = json.dumps({ # json string used in HTTP requests\r\n 'jsonrpc': '2.0',\r\n 'method': method,\r\n 'params': params,\r\n 'id': self.id\r\n })\r\n url = \"http://{}:{}\".format(self.ip.address, self.rpc_port)\r\n with SEMAPHORE:\r\n with requests.Session() as r:\r\n # sleep(0.01) ###\r\n response = r.post(url=url, data=data, headers=self._headers)\r\n while response.headers['Content-Type'] != 'application/json':\r\n print(self.ip.address, self.rpc_port)\r\n print(response.status_code, response.headers)\r\n print(response.content)\r\n sleep(0.05)\r\n response = r.post(url=url, data=data, headers=self._headers)\r\n content = response.json()\r\n # sleep(0.02)\r\n print(content)\r\n result = content.get('result')\r\n err = content.get('error')\r\n if err:\r\n raise RuntimeError(self.ip.address, self.rpc_port, err.get('message'))\r\n\r\n print('%s @%s : %s %s' % (method, self.ip.address, self.rpc_port, result))\r\n return result","async def call_rpc(self, rpc_message: RpcMessage, options: dict, bus_client: \"BusClient\"):\n raise NotImplementedError()","def _call_method(self, module, method, *args, **kwargs):\n if not self._is_vim_object(module):\n return self.invoke_api(module, method, self.vim, *args, **kwargs)\n else:\n return self.invoke_api(module, method, *args, **kwargs)","def testNoSuchRemoteMethod(self):\n self.ExpectRpcError(self.rpc_mapper1,\n remote.RpcState.METHOD_NOT_FOUND_ERROR,\n 'Unrecognized RPC method: not_remote')\n\n self.mox.ReplayAll()\n\n self.handler.handle('POST', '/my_service', 'not_remote')\n\n self.VerifyResponse('400', 'Unrecognized RPC method: not_remote', '')\n\n self.mox.VerifyAll()","def _do_call(cls, method, url, params={}):\n headers = {\n 'User-Agent': 'py-retain/' + __version__,\n 'content-type': 'application/json'\n }\n try:\n r = cls.request_map[method.lower()]\n except KeyError:\n raise ValueError(\"Unknow HTTP Method\")\n response = r(\n url,\n auth=(cls.app_id, cls.api_key),\n headers=headers,\n data=json.dumps(params),\n timeout=cls.timeout)\n return response.json()","def call(self, service, method, *args, **kwargs):\r\n if kwargs.pop('iter', False):\r\n return self.iter_call(service, method, *args, **kwargs)\r\n\r\n invalid_kwargs = set(kwargs.keys()) - VALID_CALL_ARGS\r\n if invalid_kwargs:\r\n raise TypeError(\r\n 'Invalid keyword arguments: %s' % ','.join(invalid_kwargs))\r\n\r\n if not service.startswith(self._prefix):\r\n service = self._prefix + service\r\n\r\n headers = kwargs.get('headers', {})\r\n\r\n if self.auth:\r\n headers.update(self.auth.get_headers())\r\n\r\n if kwargs.get('id') is not None:\r\n headers[service + 'InitParameters'] = {'id': kwargs.get('id')}\r\n\r\n if kwargs.get('mask') is not None:\r\n headers.update(self.__format_object_mask(kwargs.get('mask'),\r\n service))\r\n\r\n if kwargs.get('filter') is not None:\r\n headers['%sObjectFilter' % service] = kwargs.get('filter')\r\n\r\n if kwargs.get('limit'):\r\n headers['resultLimit'] = {\r\n 'limit': kwargs.get('limit'),\r\n 'offset': kwargs.get('offset', 0),\r\n }\r\n\r\n http_headers = {\r\n 'User-Agent': USER_AGENT,\r\n 'Content-Type': 'application/xml',\r\n }\r\n\r\n if kwargs.get('compress', True):\r\n http_headers['Accept'] = '*/*'\r\n http_headers['Accept-Encoding'] = 'gzip, deflate, compress'\r\n\r\n if kwargs.get('raw_headers'):\r\n http_headers.update(kwargs.get('raw_headers'))\r\n\r\n uri = '/'.join([self.endpoint_url, service])\r\n return make_xml_rpc_api_call(uri, method, args,\r\n headers=headers,\r\n http_headers=http_headers,\r\n timeout=self.timeout,\r\n proxy=self.proxy)","def call_thread_method(self, name, *args, **kwargs):\n return self._thread_methods[name](*args,**kwargs)","def call_firstresult(self, methname, *args, **kwargs): \n return MultiCall(self.listattr(methname), *args, **kwargs).execute(firstresult=True)","def _call(self, args):\n a = args.split(' ', 1)\n if a:\n getattr(self, a[0])(*a[1:])","def rpc(self) -> global___Rpc:","def method(self,methodname):\n\t\tif methodname in self.methods:\n\t\t\treturn self.methods[methodname]\n\t\treturn None","def xmlrpc_method(returns='string', args=None, name=None):\r\n # Args should be a list\r\n if args is None:\r\n args = []\r\n\r\n def _xmlrpc_func(func):\r\n \"\"\"Inner function for XML-RPC method decoration. Adds a signature to\r\n the method passed to it.\r\n\r\n func\r\n The function to add the signature to\r\n \"\"\"\r\n # Add a signature to the function\r\n func._xmlrpc_signature = {\r\n 'returns': returns,\r\n 'args': args\r\n }\r\n return func\r\n\r\n return _xmlrpc_func","def exec(self, method=\"get\", content_type=\"application/json\"):\n str_method = method.lower()\n m = self.i[\"method\"].split()\n\n if str_method in m:\n try:\n par_dict = {}\n par_man = match(self.op, self.op_url).groups()\n for idx, par in enumerate(findall(\"{([^{}]+)}\", self.i[\"url\"])):\n try:\n par_type = self.i[par].split(\"(\")[0]\n if par_type == \"str\":\n par_value = par_man[idx]\n else:\n par_value = self.dt.get_func(par_type)(par_man[idx])\n except KeyError:\n par_value = par_man[idx]\n par_dict[par] = par_value\n\n if self.addon is not None:\n self.preprocess(par_dict, self.i, self.addon)\n\n query = self.i[\"sparql\"]\n for param in par_dict:\n query = query.replace(\"[[%s]]\" % param, str(par_dict[param]))\n\n if self.sparql_http_method == \"get\":\n r = get(\n self.tp + \"?query=\" + quote(query),\n headers={\"Accept\": \"text/csv\"},\n )\n else:\n r = post(\n self.tp,\n data=query,\n headers={\n \"Accept\": \"text/csv\",\n \"Content-Type\": \"application/sparql-query\",\n },\n )\n r.encoding = \"utf-8\"\n sc = r.status_code\n if sc == 200:\n # This line has been added to avoid a strage behaviour of the 'splitlines' method in\n # presence of strange characters (non-UTF8).\n list_of_lines = [\n line.decode(\"utf-8\")\n for line in r.text.encode(\"utf-8\").splitlines()\n ]\n res = self.type_fields(list(reader(list_of_lines)), self.i)\n if self.addon is not None:\n res = self.postprocess(res, self.i, self.addon)\n q_string = parse_qs(quote(self.url_parsed.query, safe=\"&=\"))\n res = self.handling_params(q_string, res)\n res = self.remove_types(res)\n s_res = StringIO()\n writer(s_res).writerows(res)\n return (sc,) + Operation.conv(\n s_res.getvalue(), q_string, content_type\n )\n else:\n return sc, \"HTTP status code %s: %s\" % (sc, r.reason), \"text/plain\"\n except TimeoutError:\n exc_type, exc_obj, exc_tb = exc_info()\n sc = 408\n return (\n sc,\n \"HTTP status code %s: request timeout - %s: %s (line %s)\"\n % (sc, exc_type.__name__, exc_obj, exc_tb.tb_lineno),\n \"text/plain\",\n )\n except TypeError:\n exc_type, exc_obj, exc_tb = exc_info()\n sc = 400\n return (\n sc,\n \"HTTP status code %s: \"\n \"parameter in the request not compliant with the type specified - %s: %s (line %s)\"\n % (sc, exc_type.__name__, exc_obj, exc_tb.tb_lineno),\n \"text/plain\",\n )\n except:\n exc_type, exc_obj, exc_tb = exc_info()\n sc = 500\n return (\n sc,\n \"HTTP status code %s: something unexpected happened - %s: %s (line %s)\"\n % (sc, exc_type.__name__, exc_obj, exc_tb.tb_lineno),\n \"text/plain\",\n )\n else:\n sc = 405\n return (\n sc,\n \"HTTP status code %s: '%s' method not allowed\" % (sc, str_method),\n \"text/plain\",\n )","def SoapAction(self) -> str:","def _handler(self, message):\n\n data = pickle.loads(message['data'])\n\n if not data[2]:\n # empty method call; bail out\n return\n\n # call the function and respond to the proxy object with return value\n uuid = data[0]\n proxy = data[1]\n func = getattr(self, data[2])\n result = (uuid, func(*data[3], **data[4]))\n self._redis.publish('proxy:%s' % proxy, pickle.dumps(result))","def call(self) -> global___Snippet.ClientCall:","def call(self) -> global___Snippet.ClientCall:","def get_method(self, method): \n for provider in self.method_handlers:\n for candidate in provider.xmlrpc_methods():\n #self.env.log.debug(candidate)\n p = Method(provider, *candidate)\n if p.name == method:\n return p\n raise MethodNotFound('RPC method \"%s\" not found' % method)","def rpc_method(func):\n func.rpc_callable = True\n return func","def call(self, method, params, callback=None):\n cur_id = self._next_id()\n if callback:\n self._callbacks[cur_id] = callback\n self.send({'msg': 'method', 'id': cur_id, 'method': method, 'params': params})","def call(self, method, params, callback=None):\n cur_id = self._next_id()\n if callback:\n self._callbacks[cur_id] = callback\n self.send({'msg': 'method', 'id': cur_id, 'method': method, 'params': params})","def _call(self, method, endpoint, content=None, params=None):\n\t\tparams = params or {}\n\t\tcontent = content or {}\n\n\t\tjson_data = json.dumps(content)\n\t\tendpoint = endpoint.strip(\"/\")\n\t\theaders = {\"X-Signed-Request-Hash\": self.__sign(method, endpoint, json_data)}\n\n\t\tresponse = self.session.request(\n\t\t\tmethod=method,\n\t\t\turl=(CloudClient.BASE_API + endpoint),\n\t\t\theaders = headers,\n\t\t\tparams=params,\n\t\t\tdata = json_data\n\t\t)\n\n\t\treturn WeeblyCloudResponse(self.session, response)","def __call__(self, api_function):\n return hug_core.interface.Local(self.route, api_function)","def post(self):\n return getServiceListMethod(self)","def client_static_function(self, method: ProtoServiceMethod) -> None:"],"string":"[\n \"def _call(self, rpc_method_name, *args, **kwargs):\\n method = getattr(self, rpc_method_name)\\n return method(*args, **kwargs)\",\n \"def _method_call(self, msg):\\n #print(\\\"Performing service: %s, method_name: %s\\\" % (msg.service_name, msg.method_name))\\n service = self._services.get(msg.service_name)\\n if service is None:\\n raise MessageHandleError(MessageHandleError.RESULT_UNKNOWN_SERVICE, msg)\\n\\n try:\\n return execute_remote_method_call(service, msg.method_name, *msg.pargs, **msg.kwargs)\\n #return service.call(msg.method_name, *msg.pargs, **msg.kwargs)\\n except MessageHandleError as error:\\n error.original_message = msg\\n raise error\",\n \"def callRemote(self, methname, *args, **kwargs):\\n schema = self._referenceable.getInterface()[methname]\\n if self.check_args:\\n schema.checkAllArgs(args, kwargs, inbound=False)\\n # TODO: Figure out how to call checkResults on the result.\\n return execute(\\n self._referenceable.doRemoteCall,\\n methname,\\n args,\\n kwargs,\\n )\",\n \"def callRemote(self, methname, *args, **kwargs):\\n try:\\n schema = self._referenceable.getInterface()[methname]\\n if self.check_args:\\n schema.checkAllArgs(args, kwargs, inbound=True)\\n _check_copyables(list(args) + kwargs.values())\\n result = self._referenceable.doRemoteCall(\\n methname,\\n args,\\n kwargs,\\n )\\n schema.checkResults(result, inbound=False)\\n _check_copyables([result])\\n return succeed(result)\\n except:\\n return fail()\",\n \"def call(self, method, name, params=None, payload=None, **kwds):\",\n \"def callRemote(self, name, *args, **kw):\\n if hasattr(self, 'sync_'+name):\\n return getattr(self, 'sync_'+name)(*args, **kw)\\n try:\\n method = getattr(self, \\\"async_\\\" + name)\\n return defer.succeed(method(*args, **kw))\\n except:\\n f = Failure()\\n if self.reportAllTracebacks:\\n f.printTraceback()\\n return defer.fail(f)\",\n \"def export_callProxyMethod( self, name, args, kargs ):\\n res = pythonCall( 120, self.__proxyWrapper, name, args, kargs )\\n if res['OK']:\\n return res['Value']\\n else:\\n return res\",\n \"def execute(self, methodname, *args):\\n if not methodname in self.methods:\\n raise BlogError(BlogError.METHOD_NOT_SUPPORTED)\\n\\n try:\\n r = getattr(self.server, methodname)(args)\\n except xmlrpclib.Fault, fault:\\n raise BlogError(fault.faultString)\\n\\n return r\",\n \"def call(self, name, *args, **kwargs):\\r\\n return self.client.call(self.name, name, *args, **kwargs)\",\n \"def __executeOperation( self, url, method ):\\n fcn = None\\n if hasattr( self, method ) and callable( getattr( self, method ) ):\\n fcn = getattr( self, method )\\n if not fcn:\\n return S_ERROR( \\\"Unable to invoke %s, it isn't a member function of DIPStorage\\\" % method )\\n\\n res = fcn( url )\\n if not res['OK']:\\n return res\\n elif url not in res['Value']['Successful']:\\n return S_ERROR( res['Value']['Failed'][url] )\\n\\n return S_OK( res['Value']['Successful'][url] )\",\n \"def remote(self, method, params=()):\\n\\n response = self.transport.request(self.host, \\n '/RPC2',\\n dumps(params, method))\\n return response\",\n \"def call(self, method, *args, **kwargs):\\n if method in self.handlers:\\n handler = self.handlers[method]\\n if self.single_server:\\n self.send_request(self.single_server, method, handler, *args, **kwargs)\\n else:\\n if method in [\\\"completion\\\", \\\"completion_item_resolve\\\", \\\"diagnostics\\\", \\\"code_action\\\", \\\"execute_command\\\"]:\\n method_server_names = self.multi_servers_info[method]\\n else:\\n method_server_names = [self.multi_servers_info[method]]\\n\\n for method_server_name in method_server_names:\\n method_server = self.multi_servers[method_server_name]\\n self.send_request(method_server, method, handler, *args, **kwargs)\\n elif hasattr(self, method):\\n getattr(self, method)(*args, **kwargs)\",\n \"def call(self, obj_name, method_name, param_dict=dict()):\\n result = self.ctrl_client.call(obj_name, method_name, param_dict)\\n if result['type'] == 'error':\\n self.logger.error(\\\"API call error: {}\\\".format(result['msg']))\\n return None\\n else:\\n return result['call_return']\",\n \"def _call_method(self, module, method, *args, **kwargs):\\n return self.invoke_api(module, method, *args, **kwargs)\",\n \"def __call__(self):\\n params, method = parse_xmlrpc_request(self.request)\\n return xmlrpc_response(getattr(self,method)(*params))\",\n \"def callRemote(self, _name, *args, **kw):\\r\\n if self.__failure is not None:\\r\\n d = fail(self.__failure)\\r\\n elif self.__pending is not None:\\r\\n d = Deferred()\\r\\n self.__pending.append(d)\\r\\n else:\\r\\n d = succeed(self.__obj)\\r\\n\\r\\n d.addCallback(lambda ref: ref.callRemote(_name, *args, **kw))\\r\\n d.addErrback(self.__filter, _name)\\r\\n return d\",\n \"def _remote_call(self,\\n method_name,\\n target='Widget',\\n args=None,\\n kwargs=None):\\n args = [] if args is None else args\\n kwargs = {} if kwargs is None else kwargs\\n\\n msg = {}\\n\\n if 'component_index' in kwargs:\\n msg['component_index'] = kwargs.pop('component_index')\\n if 'repr_index' in kwargs:\\n msg['repr_index'] = kwargs.pop('repr_index')\\n\\n msg['target'] = target\\n msg['type'] = 'call_method'\\n msg['methodName'] = method_name\\n msg['args'] = args\\n msg['kwargs'] = kwargs\\n\\n def callback(widget, msg=msg):\\n widget.send(msg)\\n\\n callback._method_name = method_name\\n callback._ngl_msg = msg\\n\\n if self.loaded:\\n self._remote_call_thread.q.append(callback)\\n else:\\n # send later\\n # all callbacks will be called right after widget is loaded\\n self._ngl_displayed_callbacks_before_loaded.append(callback)\\n\\n if callback._method_name not in _EXCLUDED_CALLBACK_AFTER_FIRING:\\n self._ngl_displayed_callbacks_after_loaded.append(callback)\",\n \"def _execApiCall(headers, params, method_name,\\r\\n domain='ma.gnolia.com',\\r\\n urlhead='/api/rest/1/'):\\r\\n \\r\\n if 'api_key' not in params and method_name not in ['echo', 'get_key']:\\r\\n raise MagnoliaException('Required API Key parameter missing')\\r\\n conn = httplib.HTTPConnection(domain)\\r\\n conn.request('POST', urlhead + method_name, params, headers)\\r\\n return conn.getresponse()\",\n \"def __getattr__(self, method):\\n def run_callback(func, plus, result):\\n \\\"\\\"\\\"Execute the given callback safely.\\n Get data and/or error from result and call func passing it\\n data, plus (if needed) and error. Catch, log and suppress\\n all exceptions.\\n func (function): the callback to invoke.\\n plus (object): optional additional data.\\n result (AsyncResult): the result of a (finished) RPC call.\\n \\\"\\\"\\\"\\n data = result.value\\n error = None if result.successful() else \\\"%s\\\" % result.exception\\n try:\\n if plus is None:\\n func(data, error=error)\\n else:\\n func(data, plus, error=error)\\n except Exception as error:\\n logger.error(\\\"RPC callback for %s.%s raised exception.\\\",\\n self.remote_service_coord.name, method,\\n exc_info=True)\\n\\n def remote_method(**data):\\n \\\"\\\"\\\"Forward arguments to execute_rpc.\\n \\\"\\\"\\\"\\n callback = data.pop(\\\"callback\\\", None)\\n plus = data.pop(\\\"plus\\\", None)\\n result = self.execute_rpc(method=method, data=data)\\n if callback is not None:\\n callback = functools.partial(run_callback, callback, plus)\\n result.rawlink(functools.partial(gevent.spawn, callback))\\n return result\\n\\n return remote_method\",\n \"def call(self, uri, method, arg, extras):\\n pass\",\n \"def do_rpc(self, method, **params):\\n data = {\\n 'jsonrpc': '2.0',\\n 'method': method,\\n 'params': params,\\n 'authorization': self._auth_token,\\n 'id': '1'\\n }\\n\\n r = requests.post(self._url, json=data)\\n validate_response(r)\\n\\n return r.json()['result']\",\n \"def call(self, port, method, *args, **kwargs):\\n method = self.provides[port][method]\\n return method(*args, **kwargs)\",\n \"def xen_rpc_call(ip, method, *args):\\n try:\\n if not ip:\\n return xen_api_error(\\\"Invalid ip for rpc call\\\")\\n # create\\n proxy = ServerProxy(\\\"http://\\\" + ip + \\\":9363/\\\")\\n \\n # login \\n response = proxy.session.login('root')\\n if cmp(response['Status'], 'Failure') == 0:\\n log.exception(response['ErrorDescription'])\\n return xen_api_error(response['ErrorDescription']) \\n session_ref = response['Value']\\n \\n # excute\\n method_parts = method.split('_')\\n method_class = method_parts[0]\\n method_name = '_'.join(method_parts[1:])\\n \\n if method.find(\\\"host_metrics\\\") == 0:\\n method_class = \\\"host_metrics\\\"\\n method_name = '_'.join(method_parts[2:])\\n #log.debug(method_class)\\n #log.debug(method_name)\\n if method_class.find(\\\"Async\\\") == 0:\\n method_class = method_class.split(\\\".\\\")[1]\\n response = proxy.__getattr__(\\\"Async\\\").__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\\n else:\\n response = proxy.__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\\n if cmp(response['Status'], 'Failure') == 0:\\n log.exception(response['ErrorDescription'])\\n return xen_api_error(response['ErrorDescription'])\\n # result\\n return response\\n except socket.error:\\n return xen_api_error('socket error')\",\n \"def call(self, method=None, args=[]):\\n\\n client = xmlclient.ServerProxy(uri=self.api_endpoint, encoding='utf-8',\\n allow_none=True)\\n response = getattr(client, method)(self.username, self.password, *args)\\n if response == 'OK':\\n return True\\n elif 'AUTH_ERROR' in response:\\n raise AuthError()\\n elif response == 'DOMAIN_OCCUPIED':\\n raise DomainOccupiedError()\\n elif response == 'RATE_LIMITED':\\n raise RateLimitedError()\\n elif response == 'BAD_INDATA':\\n raise BadInDataError()\\n elif response == 'UNKNOWN_ERROR':\\n raise UnknownError()\\n else:\\n return response\",\n \"def _dispatch(self, method, params):\\n logging.debug('Calling %s%s', method, params)\\n self._rpc_received_event.set()\\n return SimpleJSONRPCServer.SimpleJSONRPCServer._dispatch(\\n self, method, params)\",\n \"def call_rpc(rpc_user, rpc_pwd, method):\\n base_url = 'http://127.0.0.1:37128/'\\n try:\\n response = post(base_url,\\n data=method,\\n auth=(rpc_user, rpc_pwd)\\n )\\n except Exception as e:\\n response = e\\n return evaluate_response(response)\",\n \"def __call__(self, **action_kwargs):\\n\\n return SOAP.send(self.service, self, **action_kwargs)\",\n \"def call_selenium_api(self, method_name, *args):\\n try:\\n method = getattr(self._selenium, method_name)\\n except AttributeError:\\n method = lambda *args: self._selenium.do_command(method_name, args)\\n return method(*args)\",\n \"def api_call(self, method, host, params):\\n session_id = self.rpc_login(host)\\n params.insert(0, session_id)\\n json_rpc_request = {\\n 'jsonrpc': '2.0',\\n 'method': method,\\n 'params': params,\\n 'id': self.ID\\n }\\n\\n self.ID += 1\\n response = requests.post(host, data=json.dumps(json_rpc_request), headers=self.headers)\\n\\n return response\",\n \"def send_method_call(self, service_name, method_name, *pargs, **kwargs):\\n msg = MethodCallMessage(service_name=service_name, method_name=method_name, pargs=pargs, kwargs=kwargs)\\n return self.send_message_blocking(msg)\",\n \"def remote_method(**data):\\n callback = data.pop(\\\"callback\\\", None)\\n plus = data.pop(\\\"plus\\\", None)\\n result = self.execute_rpc(method=method, data=data)\\n if callback is not None:\\n callback = functools.partial(run_callback, callback, plus)\\n result.rawlink(functools.partial(gevent.spawn, callback))\\n return result\",\n \"def call_method(self, request, context):\\n response = CallMethodResponse()\\n args = []\\n for arg in request.args:\\n args.append(decode(arg))\\n if args != []:\\n result = \\\\\\n self._delegator.call_method(\\n request.component, request.method, *args)\\n else:\\n result = \\\\\\n self._delegator.call_method(\\n request.component, request.method, None)\\n response.result = encode(result)\\n return response\",\n \"def make_call(self, method, _):\\n raise CallNotFound('{}.{} does not exist'.format(self.service_name,\\n method))\",\n \"def xmlrpc_methods():\",\n \"def make_xml_rpc_api_call(uri, method, args=None, headers=None,\\r\\n http_headers=None, timeout=None, proxy=None):\\r\\n if args is None:\\r\\n args = tuple()\\r\\n try:\\r\\n largs = list(args)\\r\\n largs.insert(0, {'headers': headers})\\r\\n\\r\\n payload = xmlrpc_client.dumps(tuple(largs),\\r\\n methodname=method,\\r\\n allow_none=True)\\r\\n session = requests.Session()\\r\\n req = requests.Request('POST', uri, data=payload,\\r\\n headers=http_headers).prepare()\\r\\n LOGGER.debug(\\\"=== REQUEST ===\\\")\\r\\n LOGGER.info('POST %s', uri)\\r\\n LOGGER.debug(req.headers)\\r\\n LOGGER.debug(payload)\\r\\n\\r\\n response = session.send(req,\\r\\n timeout=timeout,\\r\\n proxies=_proxies_dict(proxy))\\r\\n LOGGER.debug(\\\"=== RESPONSE ===\\\")\\r\\n LOGGER.debug(response.headers)\\r\\n LOGGER.debug(response.content)\\r\\n response.raise_for_status()\\r\\n result = xmlrpc_client.loads(response.content,)[0][0]\\r\\n return result\\r\\n except xmlrpc_client.Fault as ex:\\r\\n # These exceptions are formed from the XML-RPC spec\\r\\n # http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php\\r\\n error_mapping = {\\r\\n '-32700': NotWellFormed,\\r\\n '-32701': UnsupportedEncoding,\\r\\n '-32702': InvalidCharacter,\\r\\n '-32600': SpecViolation,\\r\\n '-32601': MethodNotFound,\\r\\n '-32602': InvalidMethodParameters,\\r\\n '-32603': InternalError,\\r\\n '-32500': ApplicationError,\\r\\n '-32400': RemoteSystemError,\\r\\n '-32300': TransportError,\\r\\n }\\r\\n raise error_mapping.get(ex.faultCode, SoftLayerAPIError)(\\r\\n ex.faultCode, ex.faultString)\\r\\n except requests.HTTPError as ex:\\r\\n raise TransportError(ex.response.status_code, str(ex))\\r\\n except requests.RequestException as ex:\\r\\n raise TransportError(0, str(ex))\",\n \"def get_method(self, name):\\n try:\\n return self.methods[name]\\n except KeyError:\\n raise ServiceException('Service method \\\"%s\\\" not registered' % name)\",\n \"def call_method(self, name, method, params):\\n self.logger.debug(\\\"API call: {}.{}({})\\\".format(name, method, params))\\n if name in self.systems:\\n obj = self.systems[name]\\n if is_api_method(obj, method):\\n try:\\n # Calls given obj.method, unpacking and passing params dict\\n call_return = getattr(obj, method)(**params)\\n msg = \\\"Called {}.{}\\\".format(name, method)\\n self.logger.debug(msg + \\\",returned:{}\\\".format(call_return))\\n return msgs.call_reply(msg, call_return)\\n except TypeError:\\n # Raised when we have a mismatch of the method's kwargs\\n # TODO: Return argspec here?\\n err_msg = \\\"Invalid params for {}.{}\\\".format(name, method)\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\\n except Exception as e:\\n # Catch exception raised by called method, notify client\\n err_msg = \\\"Exception: '{}'\\\".format(str(e))\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\\n else:\\n err_msg = \\\"Invalid method: '{}.{}'\\\".format(name, method)\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\\n else:\\n err_msg = \\\"Invalid object: '{}'\\\".format(name)\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\",\n \"def call(self, name, request=None, **params):\\r\\n if not name in self.resources:\\r\\n raise exceptions.HttpError('Unknown method \\\\'%s\\\\'' % name,\\r\\n status=status.HTTP_501_NOT_IMPLEMENTED)\\r\\n request = request or HttpRequest()\\r\\n resource = self.resources[name]\\r\\n view = resource.as_view(api=self)\\r\\n return view(request, **params)\",\n \"def call_method(self, action):\\n\\n\\t\\tif action[0] in self.methods:\\n\\t\\t\\tself.methods[action[0]](action[0:])\\n\\t\\telse:\\n\\t\\t\\tself.no_such_method()\",\n \"def _execute_impl(self, *args, **kwargs):\\n # Execute with bound args.\\n method_body = getattr(self._deployment_node, self._deployment_method_name)\\n return method_body.remote(\\n *self._bound_args,\\n **self._bound_kwargs,\\n )\",\n \"def __call__(self, method, *args, **kwargs):\\n if hasattr(self, 'channel'):\\n kwargs.setdefault('channel', self.channel)\\n resp = self._client.api_call(method, *args, **kwargs)\\n if not resp['ok']:\\n print unicode(resp)\\n raise RuntimeError(resp.get('error', unicode(resp)))\\n return resp\",\n \"def rpc_call(self, request, method=None, params=None, **kwargs):\\r\\n args = []\\r\\n kwargs = dict()\\r\\n if isinstance(params, dict):\\r\\n kwargs.update(params)\\r\\n else:\\r\\n args = list(as_tuple(params))\\r\\n\\r\\n method_key = \\\"{0}.{1}\\\".format(self.scheme_name, method)\\r\\n if method_key not in self.methods:\\r\\n raise AssertionError(\\\"Unknown method: {0}\\\".format(method))\\r\\n method = self.methods[method_key]\\r\\n\\r\\n if hasattr(method, 'request'):\\r\\n args.insert(0, request)\\r\\n\\r\\n return method(*args, **kwargs)\",\n \"def call(self, **kwargs):\\n return getattr(self.resource, self.function)(**kwargs)\",\n \"def _ExecuteRequest(request):\\n service = request.service_name()\\n method = request.method()\\n service_methods = remote_api_services.SERVICE_PB_MAP.get(service, {})\\n request_class, response_class = service_methods.get(method, (None, None))\\n if not request_class:\\n raise apiproxy_errors.CallNotFoundError('%s.%s does not exist' % (service,\\n method))\\n\\n request_data = request_class()\\n request_data.ParseFromString(request.request())\\n response_data = response_class()\\n\\n def MakeRequest():\\n apiproxy_stub_map.MakeSyncCall(service, method, request_data,\\n response_data)\\n\\n\\n\\n if service in THREAD_SAFE_SERVICES:\\n MakeRequest()\\n else:\\n with GLOBAL_API_LOCK:\\n MakeRequest()\\n return response_data\",\n \"def\\trunMethod(self, name = \\\"__default\\\", prms = {}):\\n\\n\\t\\tprms = self.CSLBuildPrmList(prms)\\n\\t\\tlocalTbl = { 'vars':{}, 'status':0, 'props':{}, 'alias':{}, 'persistent':{}, 'instance':{}}\\n\\n\\t\\tres = self.callMethod(name, prms, localTbl)\\n\\n\\t\\tif localTbl[\\\"status\\\"] == 2:\\n\\t\\t\\treturn self.COMARValue.COMARRetVal(1, None)\\n\\t\\telse:\\t\\t\\t\\n\\t\\t\\tret = self.CSLtoCOMARValue(res)\\n\\t\\t\\tself.debug(DEBUG_FATAL, \\\"RETS:\\\", res, '(%s)->' % (res.type), ret)\\n\\t\\t\\treturn self.COMARValue.COMARRetVal(0, ret)\",\n \"def ServiceMethod(fn):\\n\\n fn.IsServiceMethod = True\\n return fn\",\n \"def client_member_function(self, method: ProtoServiceMethod) -> None:\",\n \"def rpc_request(method, params, url=LOCAL):\\n client = HTTPClient(url)\\n return client.request(method, params)\",\n \"def call(self, method, *args):\\n flatcall = flatten(\\n m(n=method, t=self.groupName)[[\\n squish(x) for x in args if x is not None]])\\n self.socket.write(flatcall + '\\\\0')\",\n \"def call_method(self, method_name: str, timeout=None, **params) -> dict:\\n timeout = timeout or self.timeout\\n request_id = uuid.uuid4().hex\\n data = {'@type': method_name,\\n '@extra': {'request_id': request_id}}\\n data.update(params)\\n self._tdjson_client.send(data)\\n\\n result = self._wait_result(request_id, timeout)\\n return result\",\n \"def execute_rpc(self, method, data):\\n result = gevent.event.AsyncResult()\\n result.set_exception(\\n RPCError(\\\"Called a method of a non-configured service.\\\"))\\n return result\",\n \"def rpc_call(self, ctx, rpc_request):\\n rpc_method = rpc_request['method']\\n start_time = time.time()\\n try:\\n return self._rpc_call([ctx.proxyfsd_addrinfo], rpc_request)\\n finally:\\n duration = time.time() - start_time\\n self.logger.debug(\\\"RPC %s took %.6fs\\\", rpc_method, duration)\",\n \"def __call__(self, method, url, *args, **kwargs):\\n log.debug('{} {}'.format(method.upper(), url))\\n if 'params' in kwargs:\\n kwargs['query'] = kwargs.pop('params')\\n return getattr(self.client, method)(url, *args, **kwargs).json\",\n \"def call(self, method, **kwargs):\\n response = self._do_request(method, **kwargs)\\n return self._deserialize_response(response)\",\n \"def call(self, command, *args, **kwargs):\\n\\n\\tif command in self.command_table:\\n\\t cmdopts = self.command_table[command]\\n\\t function = cmdopts.get('function', None)\\n\\t method = cmdopts.get('method', None)\\n\\t template = cmdopts.get('url_template', None)\\n\\t retval = function(method, template, *args, **kwargs)\\n\\t if not retval:\\n\\t\\traise RuntimeError, 'request returned no data'\\n\\t return retval\\n\\telse:\\n\\t raise RuntimeError, 'unknown command: %s' % command\",\n \"def _platformix_call(self, context, fake_reply, method, *args, **kwargs):\\r\\n if hasattr(self.host, method):\\r\\n if not callable(getattr(self.host, method)):\\r\\n self._reply(context, proto_failure(\\\"Attribute {} of {} is a property\\\".format(\\r\\n property, self.host.name)), fake_reply)\\r\\n return\\r\\n try:\\r\\n result = getattr(self.host, method)(*args, **kwargs)\\r\\n except Exception as e:\\r\\n eprint(\\\"Platformix protocol: failed to call method {} of {} with args {}, kwargs {} \\\"\\r\\n \\\"due to exception {}\\\".format(method, self.host.name, args, kwargs, e))\\r\\n exprint()\\r\\n self._reply(context, proto_failure(\\r\\n \\\"Failed to call method {} of {} with args {}, kwargs {} \\\"\\r\\n \\\"due to exception {}\\\".format(method, self.host.name, args, kwargs, e)), fake_reply)\\r\\n return\\r\\n self._reply(context, proto_success(result), fake_reply)\\r\\n else:\\r\\n self._reply(context, proto_failure(\\\"Method {} not found on {}\\\".format(property, self.host.name)),\\r\\n fake_reply)\",\n \"def call_async(self, name, *args, **kwargs):\",\n \"def __call__(self, *args, **kwargs):\\n return self.method(*args, **kwargs)\",\n \"def _invokeMember(obj, memberName, *args, **kwargs):\\n return getattr(obj, memberName)(*args, **kwargs)\",\n \"def exec_method(self, module_name, version=None, client_class=None,\\n method_name=None, *args, **kwargs):\\n client_class = client_class or 'Client'\\n client_version = version or 2\\n _client = self.create_client(module_name, client_version,\\n client_class)\\n try:\\n # NOTE(kiennt): method_name could be a combination\\n # for example 'servers.list'. Here is the\\n # workaround.\\n method = getattr(_client, method_name.split('.')[0])\\n for attr in method_name.split('.')[1:]:\\n method = getattr(method, attr)\\n return method(*args, **kwargs)\\n except Exception as err:\\n raise err\",\n \"def __getattr__(self, method_name):\\n return partial(self.exec, method_name.replace(\\\"_\\\", \\\" \\\"))\",\n \"def rpcmethod(func):\\n func.rpcmethod = True\\n return func\",\n \"def _api_call(self, method, resource, **kwargs):\\n uri = \\\"/%s?%s&username=%s\\\" % (resource, urlencode(kwargs), self.username)\\n print (uri)\\n c = self.get_connection()\\n c.request(method, uri)\\n response = c.getresponse()\\n if not 200 == response.status:\\n raise GeoNameException(\\\"Expected a 200 reponse but got %s.\\\" % (response.status))\\n return self.response_handler.get_processed_data(response.read())\",\n \"def call_service(func, api_kwargs, context, request):\\n pattern = request.matched_route.pattern\\n service = request.registry['soap_services'].get(pattern)\\n request.META = request.headers.environ # to be used by soapbox, like django\\n request.service = service\\n\\n SOAP = service.version\\n\\n if request.method == 'GET' and 'wsdl' in request.params:\\n tree = py2wsdl.generate_wsdl(request.service)\\n body = etree.tostring(tree, pretty_print=True)\\n return Response(body=body, content_type=SOAP.CONTENT_TYPE)\\n\\n try:\\n xml = request.body\\n envelope = SOAP.Envelope.parsexml(xml)\\n message = envelope.Body.content()\\n soap_action = SOAP.determin_soap_action(request)\\n tagname, return_object = call_the_method(service,\\n request, message, soap_action)\\n soap_message = SOAP.Envelope.response(tagname, return_object)\\n return Response(body=soap_message, content_type=SOAP.CONTENT_TYPE)\\n except (ValueError, etree.XMLSyntaxError) as e:\\n response = SOAP.get_error_response(SOAP.Code.CLIENT, str(e))\\n except Exception, e:\\n response = SOAP.get_error_response(SOAP.Code.SERVER, str(e))\\n return Response(body=response, content_type=SOAP.CONTENT_TYPE)\",\n \"def invoke_method(self, method, uri, query_param={}, request_param={}, headers=None, **kwargs):\\n query_param.setdefault(\\\"apiKey\\\", self.api_key)\\n\\n method = method.lower()\\n\\n if method == \\\"get\\\":\\n resp = self.get(method, uri, query_param, request_param, headers, **kwargs)\\n\\n elif method == \\\"post\\\":\\n resp = self.post(method, uri, query_param, request_param, headers, **kwargs)\\n\\n elif method == \\\"delete\\\":\\n resp = self.delete(method, uri, query_param, request_param, headers, **kwargs)\\n\\n elif method == \\\"patch\\\":\\n resp = self.patch(method, uri, query_param, request_param, headers, **kwargs)\\n\\n else:\\n raise BacklogError(\\\"Not supported http method: {}\\\".format(method))\\n\\n return resp\",\n \"def _call(self, method, url, params):\\n if not url.startswith('http'):\\n url = self.root + url\\n headers = self._auth_headers()\\n headers['Content-Type'] = 'application/json'\\n\\n r = self._session.request(method, url,\\n headers=headers,\\n proxies=self.proxies,\\n params=params,\\n timeout=self.requests_timeout)\\n r.raise_for_status() # Check for error\\n return r.json()\",\n \"def on_action(self, message):\\n with self.handler.wrapee as wrapee:\\n log.debug(\\\"Calling {method} on {name}\\\", method=message['action'], name=self.name)\\n try:\\n func = getattr(wrapee, message['action'])\\n except AttributeError as ex:\\n log.warn(\\\"Trying to call a method {method} that does not exsist!\\\",\\n method=ex.args[0])\\n return\\n res, msg = func(*message['args'])\\n if not res:\\n log.warn(\\\"Error while calling {method}: {msg}\\\", msg=msg,\\n method=message['action'])\\n else:\\n log.debug(\\\"Called method succesfully\\\")\\n for protocol in self.service.protocols:\\n protocol.send_packet()\\n if msg != '':\\n protocol.send_news(msg)\",\n \"def callmethod(\\n self, method: str, *args: Sequence[Any], **kwargs: Sequence[Any]\\n ) -> List[Any]:\\n return getattr(self, method)(*args, **kwargs)\",\n \"def proxy_method(self, rest_path, sign, kwargs):\",\n \"def _exe(self, method):\\n request_path = self.request.path\\n path = request_path.split('/')\\n services_and_params = list(filter(lambda x: x!='',path))\\n\\n # Get all function names configured in the class RestHandler\\n functions = list(filter(lambda op: hasattr(getattr(self,op),'_service_name') == True and inspect.ismethod(getattr(self,op)) == True, dir(self)))\\n # Get all http methods configured in the class RestHandler\\n http_methods = list(map(lambda op: getattr(getattr(self,op),'_method'), functions))\\n\\n if method not in http_methods:\\n raise tornado.web.HTTPError(405,'The service not have %s verb' % method)\\n for operation in list(map(lambda op: getattr(self,op), functions)):\\n service_name = getattr(operation,\\\"_service_name\\\")\\n service_params = getattr(operation,\\\"_service_params\\\")\\n # If the _types is not specified, assumes str types for the params\\n services_from_request = list(filter(lambda x: x in path,service_name))\\n\\n if operation._method == self.request.method and service_name == services_from_request and len(service_params) + len(service_name) == len(services_and_params):\\n try:\\n params_values = self._find_params_value_of_url(service_name,request_path) + self._find_params_value_of_arguments(operation)\\n p_values = self._convert_params_values(params_values)\\n body = str(self.request.body,'utf-8')\\n self.request_data = None\\n if body:\\n self.request_data = json.loads(body)\\n response = operation(*p_values)\\n self.request_data = None\\n\\n if response == None:\\n return\\n\\n self.set_header(\\\"Content-Type\\\",'application/json')\\n self.write(json.dumps(response))\\n self.finish()\\n except Exception as detail:\\n self.request_data = None\\n self.gen_http_error(500,\\\"Internal Server Error : %s\\\"%detail)\\n raise\",\n \"def __call__(self, *args, **params):\\n\\t\\treturn self.send(params)\",\n \"def _dispatch(self, method, params):\\n func = None\\n try:\\n # check to see if a matching function has been registered\\n func = self.server.funcs[method]\\n except KeyError:\\n if self.server.instance is not None:\\n # check for a _dispatch method\\n if hasattr(self.server.instance, '_dispatch'):\\n return self.server.instance._dispatch(method, params)\\n else:\\n # call instance method directly\\n try:\\n func = resolve_dotted_attribute(\\n self.server.instance,\\n method,\\n self.server.allow_dotted_names\\n )\\n except AttributeError:\\n pass\\n\\n request = Request(\\n client_address=self.client_address,\\n headers=self.headers,\\n )\\n if func is not None:\\n return func(request, *params)\\n else:\\n raise Exception('method \\\"%s\\\" is not supported' % method)\",\n \"def _call_it(params): # pragma: no cover\\n instance, name, args = params\\n kwargs = {}\\n return getattr(instance, name)(*args, **kwargs)\",\n \"def _call_method(self, method, req, resp_class):\\n payload = req.SerializeToString()\\n headers = {\\n 'Content-Type': 'application/x-protobuf',\\n 'Content-Length': str(len(payload))\\n }\\n response, content = self._http.request(\\n self._url + method, method='POST', body=payload, headers=headers)\\n if response.status != 200:\\n raise RPCError(method, response, content)\\n resp = resp_class()\\n resp.ParseFromString(content)\\n return resp\",\n \"def _ServerProxy__request(self, methodname, params):\\n\\n paddedHandler = self._ServerProxy__handler\\n\\n # add on the methodName\\n sep = '&'\\n if '?' not in paddedHandler:\\n sep = '?'\\n paddedHandler = paddedHandler + \\\"%smethod=%s\\\" % (sep, methodname)\\n sep = '&'\\n\\n # add on the auth token\\n if self._authToken:\\n paddedHandler = paddedHandler + \\\"%sauth_token=%s\\\" % (sep, urllib.quote_plus(self._authToken))\\n\\n # add on the partnerId\\n if self._partnerId:\\n paddedHandler = paddedHandler + \\\"%spartner_id=%s\\\" % (sep, self._partnerId)\\n\\n # add on the userId\\n if self._userId:\\n paddedHandler = paddedHandler + \\\"%suser_id=%s\\\" % (sep, self._userId)\\n\\n EXCLUDED_PAYLOAD_CALLS = ([\\n \\\"auth.partnerLogin\\\",\\n \\\"test.\\\",\\n \\\"debug.\\\",\\n \\\"testability.\\\"\\n ])\\n encryptRequest = True\\n if self._requestCipher:\\n for excludedMethodPattern in EXCLUDED_PAYLOAD_CALLS:\\n if methodname.startswith(excludedMethodPattern):\\n encryptRequest = False\\n break\\n else:\\n encryptRequest = False\\n\\n # add the syncTime request\\n if encryptRequest and self._sync:\\n server_value, sync_time = self._sync\\n params[0]['syncTime'] = server_value + int(time.time()) - sync_time\\n\\n request = xmlrpclib.dumps(params, methodname,\\n encoding=self._ServerProxy__encoding,\\n allow_none=self._ServerProxy__allow_none)\\n\\n #print \\\"------- XML REQUEST --------\\\"\\n #print request\\n\\n if encryptRequest:\\n request = self.encodeRequest(request)\\n\\n if self.x509:\\n response = self._ServerProxy__transport.request(\\n (self._ServerProxy__host, self.x509),\\n paddedHandler,\\n request,\\n verbose=self._ServerProxy__verbose\\n )\\n else:\\n response = self._ServerProxy__transport.request(\\n self._ServerProxy__host,\\n paddedHandler,\\n request,\\n verbose=self._ServerProxy__verbose\\n )\\n\\n if len(response) == 1:\\n response = response[0]\\n\\n #print \\\"------ RESPONSE ------\\\"\\n #print response\\n\\n return response\",\n \"def rpc_call(self, method: str, params: Optional[list] = None) -> Any:\\r\\n if params is None:\\r\\n params = []\\r\\n data = json.dumps({ # json string used in HTTP requests\\r\\n 'jsonrpc': '2.0',\\r\\n 'method': method,\\r\\n 'params': params,\\r\\n 'id': self.id\\r\\n })\\r\\n url = \\\"http://{}:{}\\\".format(self.ip.address, self.rpc_port)\\r\\n with SEMAPHORE:\\r\\n with requests.Session() as r:\\r\\n # sleep(0.01) ###\\r\\n response = r.post(url=url, data=data, headers=self._headers)\\r\\n while response.headers['Content-Type'] != 'application/json':\\r\\n print(self.ip.address, self.rpc_port)\\r\\n print(response.status_code, response.headers)\\r\\n print(response.content)\\r\\n sleep(0.05)\\r\\n response = r.post(url=url, data=data, headers=self._headers)\\r\\n content = response.json()\\r\\n # sleep(0.02)\\r\\n print(content)\\r\\n result = content.get('result')\\r\\n err = content.get('error')\\r\\n if err:\\r\\n raise RuntimeError(self.ip.address, self.rpc_port, err.get('message'))\\r\\n\\r\\n print('%s @%s : %s %s' % (method, self.ip.address, self.rpc_port, result))\\r\\n return result\",\n \"async def call_rpc(self, rpc_message: RpcMessage, options: dict, bus_client: \\\"BusClient\\\"):\\n raise NotImplementedError()\",\n \"def _call_method(self, module, method, *args, **kwargs):\\n if not self._is_vim_object(module):\\n return self.invoke_api(module, method, self.vim, *args, **kwargs)\\n else:\\n return self.invoke_api(module, method, *args, **kwargs)\",\n \"def testNoSuchRemoteMethod(self):\\n self.ExpectRpcError(self.rpc_mapper1,\\n remote.RpcState.METHOD_NOT_FOUND_ERROR,\\n 'Unrecognized RPC method: not_remote')\\n\\n self.mox.ReplayAll()\\n\\n self.handler.handle('POST', '/my_service', 'not_remote')\\n\\n self.VerifyResponse('400', 'Unrecognized RPC method: not_remote', '')\\n\\n self.mox.VerifyAll()\",\n \"def _do_call(cls, method, url, params={}):\\n headers = {\\n 'User-Agent': 'py-retain/' + __version__,\\n 'content-type': 'application/json'\\n }\\n try:\\n r = cls.request_map[method.lower()]\\n except KeyError:\\n raise ValueError(\\\"Unknow HTTP Method\\\")\\n response = r(\\n url,\\n auth=(cls.app_id, cls.api_key),\\n headers=headers,\\n data=json.dumps(params),\\n timeout=cls.timeout)\\n return response.json()\",\n \"def call(self, service, method, *args, **kwargs):\\r\\n if kwargs.pop('iter', False):\\r\\n return self.iter_call(service, method, *args, **kwargs)\\r\\n\\r\\n invalid_kwargs = set(kwargs.keys()) - VALID_CALL_ARGS\\r\\n if invalid_kwargs:\\r\\n raise TypeError(\\r\\n 'Invalid keyword arguments: %s' % ','.join(invalid_kwargs))\\r\\n\\r\\n if not service.startswith(self._prefix):\\r\\n service = self._prefix + service\\r\\n\\r\\n headers = kwargs.get('headers', {})\\r\\n\\r\\n if self.auth:\\r\\n headers.update(self.auth.get_headers())\\r\\n\\r\\n if kwargs.get('id') is not None:\\r\\n headers[service + 'InitParameters'] = {'id': kwargs.get('id')}\\r\\n\\r\\n if kwargs.get('mask') is not None:\\r\\n headers.update(self.__format_object_mask(kwargs.get('mask'),\\r\\n service))\\r\\n\\r\\n if kwargs.get('filter') is not None:\\r\\n headers['%sObjectFilter' % service] = kwargs.get('filter')\\r\\n\\r\\n if kwargs.get('limit'):\\r\\n headers['resultLimit'] = {\\r\\n 'limit': kwargs.get('limit'),\\r\\n 'offset': kwargs.get('offset', 0),\\r\\n }\\r\\n\\r\\n http_headers = {\\r\\n 'User-Agent': USER_AGENT,\\r\\n 'Content-Type': 'application/xml',\\r\\n }\\r\\n\\r\\n if kwargs.get('compress', True):\\r\\n http_headers['Accept'] = '*/*'\\r\\n http_headers['Accept-Encoding'] = 'gzip, deflate, compress'\\r\\n\\r\\n if kwargs.get('raw_headers'):\\r\\n http_headers.update(kwargs.get('raw_headers'))\\r\\n\\r\\n uri = '/'.join([self.endpoint_url, service])\\r\\n return make_xml_rpc_api_call(uri, method, args,\\r\\n headers=headers,\\r\\n http_headers=http_headers,\\r\\n timeout=self.timeout,\\r\\n proxy=self.proxy)\",\n \"def call_thread_method(self, name, *args, **kwargs):\\n return self._thread_methods[name](*args,**kwargs)\",\n \"def call_firstresult(self, methname, *args, **kwargs): \\n return MultiCall(self.listattr(methname), *args, **kwargs).execute(firstresult=True)\",\n \"def _call(self, args):\\n a = args.split(' ', 1)\\n if a:\\n getattr(self, a[0])(*a[1:])\",\n \"def rpc(self) -> global___Rpc:\",\n \"def method(self,methodname):\\n\\t\\tif methodname in self.methods:\\n\\t\\t\\treturn self.methods[methodname]\\n\\t\\treturn None\",\n \"def xmlrpc_method(returns='string', args=None, name=None):\\r\\n # Args should be a list\\r\\n if args is None:\\r\\n args = []\\r\\n\\r\\n def _xmlrpc_func(func):\\r\\n \\\"\\\"\\\"Inner function for XML-RPC method decoration. Adds a signature to\\r\\n the method passed to it.\\r\\n\\r\\n func\\r\\n The function to add the signature to\\r\\n \\\"\\\"\\\"\\r\\n # Add a signature to the function\\r\\n func._xmlrpc_signature = {\\r\\n 'returns': returns,\\r\\n 'args': args\\r\\n }\\r\\n return func\\r\\n\\r\\n return _xmlrpc_func\",\n \"def exec(self, method=\\\"get\\\", content_type=\\\"application/json\\\"):\\n str_method = method.lower()\\n m = self.i[\\\"method\\\"].split()\\n\\n if str_method in m:\\n try:\\n par_dict = {}\\n par_man = match(self.op, self.op_url).groups()\\n for idx, par in enumerate(findall(\\\"{([^{}]+)}\\\", self.i[\\\"url\\\"])):\\n try:\\n par_type = self.i[par].split(\\\"(\\\")[0]\\n if par_type == \\\"str\\\":\\n par_value = par_man[idx]\\n else:\\n par_value = self.dt.get_func(par_type)(par_man[idx])\\n except KeyError:\\n par_value = par_man[idx]\\n par_dict[par] = par_value\\n\\n if self.addon is not None:\\n self.preprocess(par_dict, self.i, self.addon)\\n\\n query = self.i[\\\"sparql\\\"]\\n for param in par_dict:\\n query = query.replace(\\\"[[%s]]\\\" % param, str(par_dict[param]))\\n\\n if self.sparql_http_method == \\\"get\\\":\\n r = get(\\n self.tp + \\\"?query=\\\" + quote(query),\\n headers={\\\"Accept\\\": \\\"text/csv\\\"},\\n )\\n else:\\n r = post(\\n self.tp,\\n data=query,\\n headers={\\n \\\"Accept\\\": \\\"text/csv\\\",\\n \\\"Content-Type\\\": \\\"application/sparql-query\\\",\\n },\\n )\\n r.encoding = \\\"utf-8\\\"\\n sc = r.status_code\\n if sc == 200:\\n # This line has been added to avoid a strage behaviour of the 'splitlines' method in\\n # presence of strange characters (non-UTF8).\\n list_of_lines = [\\n line.decode(\\\"utf-8\\\")\\n for line in r.text.encode(\\\"utf-8\\\").splitlines()\\n ]\\n res = self.type_fields(list(reader(list_of_lines)), self.i)\\n if self.addon is not None:\\n res = self.postprocess(res, self.i, self.addon)\\n q_string = parse_qs(quote(self.url_parsed.query, safe=\\\"&=\\\"))\\n res = self.handling_params(q_string, res)\\n res = self.remove_types(res)\\n s_res = StringIO()\\n writer(s_res).writerows(res)\\n return (sc,) + Operation.conv(\\n s_res.getvalue(), q_string, content_type\\n )\\n else:\\n return sc, \\\"HTTP status code %s: %s\\\" % (sc, r.reason), \\\"text/plain\\\"\\n except TimeoutError:\\n exc_type, exc_obj, exc_tb = exc_info()\\n sc = 408\\n return (\\n sc,\\n \\\"HTTP status code %s: request timeout - %s: %s (line %s)\\\"\\n % (sc, exc_type.__name__, exc_obj, exc_tb.tb_lineno),\\n \\\"text/plain\\\",\\n )\\n except TypeError:\\n exc_type, exc_obj, exc_tb = exc_info()\\n sc = 400\\n return (\\n sc,\\n \\\"HTTP status code %s: \\\"\\n \\\"parameter in the request not compliant with the type specified - %s: %s (line %s)\\\"\\n % (sc, exc_type.__name__, exc_obj, exc_tb.tb_lineno),\\n \\\"text/plain\\\",\\n )\\n except:\\n exc_type, exc_obj, exc_tb = exc_info()\\n sc = 500\\n return (\\n sc,\\n \\\"HTTP status code %s: something unexpected happened - %s: %s (line %s)\\\"\\n % (sc, exc_type.__name__, exc_obj, exc_tb.tb_lineno),\\n \\\"text/plain\\\",\\n )\\n else:\\n sc = 405\\n return (\\n sc,\\n \\\"HTTP status code %s: '%s' method not allowed\\\" % (sc, str_method),\\n \\\"text/plain\\\",\\n )\",\n \"def SoapAction(self) -> str:\",\n \"def _handler(self, message):\\n\\n data = pickle.loads(message['data'])\\n\\n if not data[2]:\\n # empty method call; bail out\\n return\\n\\n # call the function and respond to the proxy object with return value\\n uuid = data[0]\\n proxy = data[1]\\n func = getattr(self, data[2])\\n result = (uuid, func(*data[3], **data[4]))\\n self._redis.publish('proxy:%s' % proxy, pickle.dumps(result))\",\n \"def call(self) -> global___Snippet.ClientCall:\",\n \"def call(self) -> global___Snippet.ClientCall:\",\n \"def get_method(self, method): \\n for provider in self.method_handlers:\\n for candidate in provider.xmlrpc_methods():\\n #self.env.log.debug(candidate)\\n p = Method(provider, *candidate)\\n if p.name == method:\\n return p\\n raise MethodNotFound('RPC method \\\"%s\\\" not found' % method)\",\n \"def rpc_method(func):\\n func.rpc_callable = True\\n return func\",\n \"def call(self, method, params, callback=None):\\n cur_id = self._next_id()\\n if callback:\\n self._callbacks[cur_id] = callback\\n self.send({'msg': 'method', 'id': cur_id, 'method': method, 'params': params})\",\n \"def call(self, method, params, callback=None):\\n cur_id = self._next_id()\\n if callback:\\n self._callbacks[cur_id] = callback\\n self.send({'msg': 'method', 'id': cur_id, 'method': method, 'params': params})\",\n \"def _call(self, method, endpoint, content=None, params=None):\\n\\t\\tparams = params or {}\\n\\t\\tcontent = content or {}\\n\\n\\t\\tjson_data = json.dumps(content)\\n\\t\\tendpoint = endpoint.strip(\\\"/\\\")\\n\\t\\theaders = {\\\"X-Signed-Request-Hash\\\": self.__sign(method, endpoint, json_data)}\\n\\n\\t\\tresponse = self.session.request(\\n\\t\\t\\tmethod=method,\\n\\t\\t\\turl=(CloudClient.BASE_API + endpoint),\\n\\t\\t\\theaders = headers,\\n\\t\\t\\tparams=params,\\n\\t\\t\\tdata = json_data\\n\\t\\t)\\n\\n\\t\\treturn WeeblyCloudResponse(self.session, response)\",\n \"def __call__(self, api_function):\\n return hug_core.interface.Local(self.route, api_function)\",\n \"def post(self):\\n return getServiceListMethod(self)\",\n \"def client_static_function(self, method: ProtoServiceMethod) -> None:\"\n]"},"negative_scores":{"kind":"list like","value":["0.72344095","0.7016205","0.6945265","0.6935145","0.6773144","0.6740759","0.6691549","0.667169","0.6600439","0.6472304","0.63347936","0.62916875","0.6260245","0.6260234","0.62297845","0.6161755","0.61566997","0.6142578","0.60809994","0.6068365","0.6018835","0.5999659","0.5979393","0.59466517","0.5936772","0.5917524","0.59063303","0.5898535","0.5888847","0.58327883","0.5819823","0.5812759","0.57909536","0.5762939","0.57540464","0.5753469","0.5740224","0.57056314","0.57008713","0.56889045","0.56634057","0.5662527","0.5646987","0.5629939","0.56171477","0.5604055","0.55708927","0.55599356","0.55094177","0.5493917","0.5473947","0.54718786","0.54648304","0.54638994","0.54581743","0.54478","0.54476047","0.54474163","0.5446686","0.5443296","0.54363257","0.5427234","0.5427015","0.5414552","0.54081243","0.54033923","0.54031295","0.53969204","0.5370876","0.5369888","0.5356865","0.5355548","0.5355164","0.53417975","0.53210396","0.532103","0.53172845","0.53129125","0.53081024","0.53058565","0.53023595","0.53003985","0.5299197","0.5293735","0.52790064","0.527514","0.5271433","0.5266537","0.5265649","0.5264083","0.52579147","0.52579147","0.52565897","0.5256426","0.52559865","0.52559865","0.52482104","0.5246863","0.52457726","0.52444935"],"string":"[\n \"0.72344095\",\n \"0.7016205\",\n \"0.6945265\",\n \"0.6935145\",\n \"0.6773144\",\n \"0.6740759\",\n \"0.6691549\",\n \"0.667169\",\n \"0.6600439\",\n \"0.6472304\",\n \"0.63347936\",\n \"0.62916875\",\n \"0.6260245\",\n \"0.6260234\",\n \"0.62297845\",\n \"0.6161755\",\n \"0.61566997\",\n \"0.6142578\",\n \"0.60809994\",\n \"0.6068365\",\n \"0.6018835\",\n \"0.5999659\",\n \"0.5979393\",\n \"0.59466517\",\n \"0.5936772\",\n \"0.5917524\",\n \"0.59063303\",\n \"0.5898535\",\n \"0.5888847\",\n \"0.58327883\",\n \"0.5819823\",\n \"0.5812759\",\n \"0.57909536\",\n \"0.5762939\",\n \"0.57540464\",\n \"0.5753469\",\n \"0.5740224\",\n \"0.57056314\",\n \"0.57008713\",\n \"0.56889045\",\n \"0.56634057\",\n \"0.5662527\",\n \"0.5646987\",\n \"0.5629939\",\n \"0.56171477\",\n \"0.5604055\",\n \"0.55708927\",\n \"0.55599356\",\n \"0.55094177\",\n \"0.5493917\",\n \"0.5473947\",\n \"0.54718786\",\n \"0.54648304\",\n \"0.54638994\",\n \"0.54581743\",\n \"0.54478\",\n \"0.54476047\",\n \"0.54474163\",\n \"0.5446686\",\n \"0.5443296\",\n \"0.54363257\",\n \"0.5427234\",\n \"0.5427015\",\n \"0.5414552\",\n \"0.54081243\",\n \"0.54033923\",\n \"0.54031295\",\n \"0.53969204\",\n \"0.5370876\",\n \"0.5369888\",\n \"0.5356865\",\n \"0.5355548\",\n \"0.5355164\",\n \"0.53417975\",\n \"0.53210396\",\n \"0.532103\",\n \"0.53172845\",\n \"0.53129125\",\n \"0.53081024\",\n \"0.53058565\",\n \"0.53023595\",\n \"0.53003985\",\n \"0.5299197\",\n \"0.5293735\",\n \"0.52790064\",\n \"0.527514\",\n \"0.5271433\",\n \"0.5266537\",\n \"0.5265649\",\n \"0.5264083\",\n \"0.52579147\",\n \"0.52579147\",\n \"0.52565897\",\n \"0.5256426\",\n \"0.52559865\",\n \"0.52559865\",\n \"0.52482104\",\n \"0.5246863\",\n \"0.52457726\",\n \"0.52444935\"\n]"},"document_score":{"kind":"string","value":"0.6306776"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":1696,"cells":{"query":{"kind":"string","value":"Returns typecodes representing input and output messages, if request and/or response fails to be generated return None for either or both. callinfo WSDLTools.SOAPCallInfo instance describing an operation."},"document":{"kind":"string","value":"def _getTypeCodes(self, callinfo):\r\n prefix = None\r\n self._resetPrefixDict()\r\n if callinfo.use == 'encoded':\r\n prefix = self._getPrefix(callinfo.namespace)\r\n try:\r\n requestTC = self._getTypeCode(parameters=callinfo.getInParameters(), literal=(callinfo.use=='literal'))\r\n except EvaluateException, ex:\r\n print \"DEBUG: Request Failed to generate --\", ex\r\n requestTC = None\r\n\r\n self._resetPrefixDict()\r\n try:\r\n replyTC = self._getTypeCode(parameters=callinfo.getOutParameters(), literal=(callinfo.use=='literal'))\r\n except EvaluateException, ex:\r\n print \"DEBUG: Response Failed to generate --\", ex\r\n replyTC = None\r\n \r\n request = response = None\r\n if callinfo.style == 'rpc':\r\n if requestTC: request = TC.Struct(pyclass=None, ofwhat=requestTC, pname=callinfo.methodName)\r\n if replyTC: response = TC.Struct(pyclass=None, ofwhat=replyTC, pname='%sResponse' %callinfo.methodName)\r\n else:\r\n if requestTC: request = requestTC[0]\r\n if replyTC: response = replyTC[0]\r\n\r\n #THIS IS FOR RPC/ENCODED, DOC/ENCODED Wrapper\r\n if request and prefix and callinfo.use == 'encoded':\r\n request.oname = '%(prefix)s:%(name)s xmlns:%(prefix)s=\"%(namespaceURI)s\"' \\\r\n %{'prefix':prefix, 'name':request.oname, 'namespaceURI':callinfo.namespace}\r\n\r\n return request, response"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def GetModelOutputInfo(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def verify_call(obj):\n\tassert obj.tag == 'OMOBJ'\n\tattr = obj[0]\n\t\n\tassert attr.tag == 'OMATTR'\n\tpairs, application = attr\n\t\n\tassert application.tag == 'OMA'\n\tsymbol, args = application\n\t\n\tassert symbol.tag == 'OMS'\n\tassert symbol.get('cd') == \"scscp1\"\n\tassert symbol.get('name') == \"procedure_call\"\n\t\n\tassert args.tag == 'OMA'\n\tassert len(args) > 0\n\tname_symbol = args[0]\n\t\n\tassert name_symbol.tag == 'OMS'\n\tcd = name_symbol.get('cd')\n\tproc_name = name_symbol.get('name')\n\t\n\t#2. Now handle the extra information\n\tassert pairs.tag == 'OMATP'\n\tassert len(pairs) % 2 == 0\n\t\n\textras = {}\n\tcall_id = None\n\treturn_type = None\n\t\n\tfor i in range(0, len(pairs), 2):\n\t\tsymbol = pairs[i]\n\t\tassert symbol.tag == 'OMS'\n\t\tassert symbol.get('cd') == \"scscp1\"\n\t\tname = symbol.get('name')\n\t\textras[name] = pairs[i+1]\n\t\t\n\t\tif name == 'call_id':\n\t\t\tassert call_id is None\n\t\t\tcall_id = pairs[i+1].text\n\t\t\tprint(call_id)\n\t\telif name.startswith('option_return_'):\n\t\t\tassert return_type is None\n\t\t\treturn_type = ReturnTypes[name[14:]]\n\t\n\t#Some information is mandatory\n\tassert call_id is not None\n\tassert return_type is not None\n\t\n\treturn cd, proc_name, call_id, return_type, args[1:], extras","def get_method_type(request_streaming, response_streaming):\n if request_streaming and response_streaming:\n return BIDI_STREAMING\n elif request_streaming and not response_streaming:\n return CLIENT_STREAMING\n elif not request_streaming and response_streaming:\n return SERVER_STREAMING\n return UNARY","def get_spi_response_type(cmd_num):\n length = 8 # Default length of a response\n resp_type = 1\n if cmd_num in [8]:\n # CMD8 gets R7\n resp_type = 7\n length = 40\n if cmd_num in [5]:\n # CMD5 gets a R4 back in SPI mode\n resp_type = 4\n length = 40\n if cmd_num in [52,53]:\n resp_type = 5\n length = 16\n \n log.debug(\"Cmd %d expects response type R%s\" %(cmd_num,resp_type))\n return (resp_type, length)","def GetNativeInputInfo(is_optional):\r\n raise Exception(\"Abstract method\")","def operation_type(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"operation_type\")","def _on_response(self, response_type, p_api1, p_api2, double1, double2, ptr1, size1, ptr2, size2, ptr3, size3):\n if self.debug:\n print \"Response: \", ord(response_type)\n if response_type == OnConnectionStatus.value:\n self._on_connect_status(p_api2, chr(int(double1)), ptr1, size1)\n elif self._callbacks:\n for callback in self._callbacks:\n if response_type == OnRtnDepthMarketData.value:\n if self._is_market:\n callback.on_market_rtn_depth_market_data_n(p_api2, ptr1)\n elif response_type == OnRspQryInstrument.value:\n obj = cast(ptr1, POINTER(InstrumentField)).contents\n callback.on_trading_rsp_qry_instrument(p_api2, obj, bool(double1))\n elif response_type == OnRspQryTradingAccount.value:\n obj = cast(ptr1, POINTER(AccountField)).contents\n callback.on_trading_rsp_qry_trading_account(p_api2, obj, bool(double1))\n elif response_type == OnRspQryInvestorPosition.value:\n obj = cast(ptr1, POINTER(PositionField)).contents\n callback.on_trading_rsp_qry_investor_position(p_api2, obj, bool(double1))\n elif response_type == OnRspQrySettlementInfo.value:\n obj = cast(ptr1, POINTER(SettlementInfoField)).contents\n callback.on_trading_rsp_qry_settlement_info(p_api2, obj, bool(double1))\n elif response_type == OnRtnOrder.value:\n obj = cast(ptr1, POINTER(OrderField)).contents\n callback.on_trading_rtn_order(p_api2, obj)\n elif response_type == OnRtnTrade.value:\n obj = cast(ptr1, POINTER(TradeField)).contents\n callback.on_trading_rtn_trade(p_api2, obj)\n elif response_type == OnRtnQuote.value:\n obj = cast(ptr1, POINTER(QuoteField)).contents\n callback.on_trading_rtn_quote(p_api2, obj)\n elif response_type == OnRtnQuoteRequest.value:\n obj = cast(ptr1, POINTER(QuoteRequestField)).contents\n callback.on_trading_rtn_quote_request(p_api2, obj)\n elif response_type == OnRspQryHistoricalTicks.value:\n obj = cast(ptr1, POINTER(TickField)).contents\n obj2 = cast(ptr2, POINTER(HistoricalDataRequestField)).contents\n callback.on_trading_rsp_qry_historical_ticks(p_api2, obj, obj2, bool(double1))\n elif response_type == OnRspQryHistoricalBars.value:\n obj = cast(ptr1, POINTER(BarField)).contents\n obj2 = cast(ptr2, POINTER(HistoricalDataRequestField)).contents\n callback.on_trading_rsp_qry_historical_bars(p_api2, obj, obj2, bool(double1))\n elif response_type == OnRspQryInvestor.value:\n obj = cast(ptr1, POINTER(InvestorField)).contents\n callback.on_trading_rsp_qry_investor(p_api2, obj)\n elif response_type == OnFilterSubscribe.value:\n instrument = c_char_p(ptr1).value\n callback.on_trading_filter_subscribe(p_api2, ExchangeType(double1), size1, size2, size3, instrument)\n elif response_type == OnRtnError.value:\n obj = cast(ptr1, POINTER(ErrorField)).contents\n if self._is_market:\n callback.on_market_rsp_error(p_api2, obj, bool(double1))\n else:\n callback.on_trading_rsp_error(p_api2, obj, bool(double1))","def RequestInformation(self, request, inInfo, outInfo):\n if self.need_to_read():\n self._read_up_front()\n self._update_time_steps()\n return 1 # NOTE: ALWAYS return 1 on pipeline methods","def _fc_out_parameters(self) -> Tuple[str, List[str]]:\n out_pars = self.ret_type.fc_ret_type()\n if len(out_pars) == 1:\n return (out_pars[0][0], [])\n\n out_par_strl = list() # type: List[str]\n for type_name, postfix in out_pars:\n out_par_strl.append('{} {}'.format(\n type_name, self.ret_type.name + postfix))\n return ('void', out_par_strl)","def __validate_input(self, request_data):\n call_id = request_data.get(strings.CALL_ID_KEY)\n request_timestamp = request_data.get(strings.TIMESTAMP_KEY)\n request_start = request_data.get(strings.START_KEY)\n validation = None\n if call_id and request_timestamp and request_start is not None:\n call_detail_query = CallDetail.objects.filter(call_id=call_id)\n if call_detail_query:\n if len(call_detail_query) < CALL_DETAILS_LIMIT:\n stored_call_detail = call_detail_query[0]\n if isinstance(request_start, str):\n if request_start in strings.TRUE_VALUES:\n request_start = True\n else:\n request_start = False\n if stored_call_detail.start == request_start:\n validation = {strings.INPUT_ERROR_KEY:\n strings.START_END_ERROR}\n stored_timestamp = standardize_date(\n stored_call_detail.timestamp,\n strings.COMPLETE_DATE_PATTERN)\n request_timestamp = standardize_date(request_timestamp,\n strings.\n COMPLETE_DATE_PATTERN)\n if stored_timestamp == request_timestamp:\n validation = {strings.INPUT_ERROR_KEY:\n strings.EQUAL_TIMESTAMPS_ERROR}\n if stored_call_detail.start and not request_start:\n if stored_timestamp > request_timestamp:\n validation = {strings.INPUT_ERROR_KEY:\n strings.SOONER_END_ERROR}\n elif not stored_call_detail.start and request_start:\n if stored_timestamp < request_timestamp:\n validation = {strings.INPUT_ERROR_KEY:\n strings.SOONER_END_ERROR}\n else:\n validation = {strings.INPUT_ERROR_KEY:\n strings.CALL_LIMIT_ERROR}\n\n return validation","def function_response_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EventSourceMappingFunctionResponseTypesItem']]]]:\n return pulumi.get(self, \"function_response_types\")","def construct_sp(self, info):\n if \"query\" in info.keys():\n if info[\"query\"].upper().startswith(\"CALL\"):\n self.q_str = info[\"query\"]\n self.sql_type_ind = (info[\"q_type_ind\"] if \"q_type_ind\" in info.keys() else\n sql_type.STORED_PROCEDURE_NO_RES)\n\n self.return_result = bool((self.sql_type_ind is sql_type.SELECT or\\\n self.sql_type_ind is sql_type.STORED_PROCEDURE_RES))\n\n elif \"procedure\" in info.keys():\n self.q_str = info[\"procedure\"]\n\n self.sql_type_ind = (info[\"q_type_ind\"] if \"q_type_ind\" in info.keys() else\n sql_type.STORED_PROCEDURE_NO_RES)\n\n self.return_result = bool((self.sql_type_ind is sql_type.SELECT or\\\n self.sql_type_ind is sql_type.STORED_PROCEDURE_RES))","def build_method_call(code, line, method_object):\n full_signature = method_object[\"methodSignature\"]\n normalised_signature = normalise_signature(full_signature)\n param_values = get_method_parameter_values(code, line, full_signature)\n string_values, cmplx_types = get_string_values(param_values, full_signature)\n\n rpc_payload_length = str(\n 4 + len(normalised_signature) + len(string_values)\n )\n # Default to stub value if method-to-service correlation failed\n strong_name = (\n method_object[\"service\"][\"strongName\"]\n if method_object[\"service\"] is not None\n else \"X\"*32\n )\n rpc_blocks = []\n rpc_blocks.extend([\n RPC_VERSION,\n RPC_FLAGS,\n rpc_payload_length,\n BASE_URL,\n strong_name,\n method_object[\"rmtSvcIntName\"],\n method_object[\"methodName\"],\n ])\n rpc_blocks.extend(normalised_signature)\n rpc_blocks.extend(string_values)\n rpc_blocks.extend([\n \"1\", \"2\", \"3\", \"4\",\n method_object[\"paramCount\"]\n ])\n rpc_blocks.extend(\n generate_parameter_map(\n rpc_blocks,\n full_signature,\n param_values\n )\n )\n return rpc_blocks, cmplx_types","def checkRequestType(packet):\n info = [packet[i : i + 2] for i in range(0, len(packet), 2)]\n RequestType = int.from_bytes(info[2], \"big\")\n if RequestType == 0x0001:\n return \"date\"\n elif RequestType == 0x0002:\n return \"time\"\n else:\n return -1","def get_operation(operation):\n if operation == 'query':\n return banking_pb2.QUERY\n if operation == 'deposit':\n return banking_pb2.DEPOSIT\n if operation == 'withdraw':\n return banking_pb2.WITHDRAW","def _handle_one_message(self):\n\n type, data = self.cxn.recv_message()\n\n if type.startswith(\"call\"):\n if len(data) != 3:\n message = (type, data)\n raise MessageError.invalid(message, \"incorrect number of args\")\n flags = {\n \"want_response\": type == \"call\",\n }\n call = Call(data[0], data[1], data[2], flags, self.client)\n self._handle_call(call)\n return False\n\n raise MessageError.bad_type(type)","def analyze_input():\n\n # Generate action_id classes for OF 1.3\n for wire_version, ordered_classes in of_g.ordered_classes.items():\n if not wire_version in [of_g.VERSION_1_3]:\n continue\n classes = versions[of_g.of_version_wire2name[wire_version]]['classes']\n for cls in ordered_classes:\n if not loxi_utils.class_is_action(cls):\n continue\n action = cls[10:]\n if action == '' or action == 'header':\n continue\n name = \"of_action_id_\" + action\n members = classes[\"of_action\"][:]\n of_g.ordered_classes[wire_version].append(name)\n if type_maps.action_id_is_extension(name, wire_version):\n # Copy the base action classes thru subtype\n members = classes[\"of_action_\" + action][:4]\n classes[name] = members\n\n # @fixme If we support extended actions in OF 1.3, need to add IDs\n # for them here\n\n for wire_version in of_g.wire_ver_map.keys():\n version_name = of_g.of_version_wire2name[wire_version]\n calculate_offsets_and_lengths(\n of_g.ordered_classes[wire_version],\n versions[version_name]['classes'],\n wire_version)","def get_response_type(cmd_num):\n length = 48 # Default length of a response\n if cmd_num in [0,4,15]:\n # No response expected\n rv = None\n if cmd_num in [11,13,16,17,18,19,23,55,56]:\n # Response type 1\n rv = 1\n if cmd_num in [7,12,20]:\n # Response type 1b, means it could also be a busy\n rv = 1.5\n if cmd_num in [2,9,10]:\n # Reponse type 2, CID/CSD register, not on SDIO but here for completeness\n length = 136\n rv = 2\n if cmd_num in [4,5]:\n rv = 4\n if cmd_num in [52,53]:\n rv = 5\n if cmd_num in [3]:\n rv = 6\n if cmd_num in [8]:\n rv = 7\n log.debug(\"Cmd %d expects response type R%s\" %(cmd_num,rv))\n return (rv, length)","def _fi_out_parameters(self) -> Tuple[str, List[Tuple[str, str]]]:\n out_pars = self.ret_type.fi_ret_type()\n if len(out_pars) == 1:\n return (out_pars[0][0], [])\n\n out_par_list = list() # type: List[Tuple[str, str]]\n for par_type, par_name in out_pars:\n out_par_list.append((par_type, 'ret_val' + par_name))\n\n return ('', out_par_list)","def processRequest(cls, ps, **kw):\n resource = kw['resource']\n method = resource.getOperation(ps, None) # This getOperation method is valid for ServiceSOAPBinding subclass\n rsp = method(ps, **kw)[1] # return (request, response) but we only need response\n return rsp","def validate_args(self, in_args, cmd_call):\n valid_1, valid_2 = None, None\n\n if len(in_args) > 0 and type(in_args) is not list:\n args = in_args.split()\n valid_1 = args[0]\n elif type(in_args) is list and len(in_args) > 0:\n args = in_args\n valid_1 = args[0]\n else:\n args = []\n\n if cmd_call in ['default']:\n # Default : Returns a valid cui type for an input cui\n # checks to see if there is more than 2 arguments\n # if so, arg[0] may be a valid code\n # arg[1] may be a valid code type\n # if not ask the user what type of code type arg[0] is\n # valid_1 = valid cui type\n # valid_2 = None\n while True:\n if len(args) >= 2 and len(args) <= 3:\n input_type = args[1].upper()\n else:\n input_type = input(\"What type of id is '{0}'? [LOCAL/RXCUI/NDC/SNOMED]\".format(args[0])).upper()\n\n # Confirm it's a valid code type\n valid_type = self.validate_id_type(input_type)\n # Valid type is a boolean of True\n if isinstance(valid_type, str) or valid_type is None:\n return None\n elif valid_type:\n break\n elif not valid_type:\n print('Invalid Option, Please Try Again')\n continue\n valid_1 = input_type\n\n elif cmd_call in self.cmd_config_default:\n # valid_1 : Valid Cui , valid_2 : Valid Cui Type\n valid_2, _ = self.validate_args(args, 'default')\n valid_1 = args[0]\n\n elif cmd_call == 'code_lookup':\n # args[0] : Initial CUI, args[1] : Initial CUI Type, args[2] : Target CUI Type\n # valid_1 : valid cui, valid_2 : list valid source and target\n _dict_opts = util.OPTIONS_CUI_TYPES.copy()\n _avail = list(set(smores.get_dict_sources()) & set(_dict_opts))\n if len(_avail) == 0 and len(args) < 2:\n print('There are no available starting cui types that can be crosswalked.\\n'\n 'Please load a file containing valid cui types: {0}'.format(_dict_opts))\n return False, None\n\n if len(args) >= 2:\n if len(args) == 3:\n # provided cui, cui source, and target\n valid_2, _ = self.validate_args(args, 'default')\n source, target = args[1].upper(), args[2].upper()\n else:\n source, target = args[0].upper(), args[1].upper()\n valid_1 = simple_input(\"Is {0} the correct starting source? \".format(source), ['YES', 'NO', 'exit'])\n if valid_1 == 'exit':\n return False, None\n # TODO need path for valid_2\n else:\n valid_1 = simple_input(\"Which code set do you want to start with?\", _avail)\n if valid_1 != 'exit':\n _dict_opts.remove(valid_1) # Don't lookup what we've already got\n valid_2 = simple_input(\"Which code set do you want to get results for?\", _dict_opts)\n if valid_2 == 'exit':\n return False, None\n else:\n return False, None\n\n elif cmd_call == 'errors':\n _current_err = list(self.errors.keys())\n if len(args) > 1:\n smores_error('#Cx001.7', console_p=True)\n return\n elif len(args) == 1 and args[0].lower() in _current_err:\n valid_1 = args[0]\n elif len(args) == 1:\n print('There are currently no errors logged for that command.')\n return\n else:\n valid_1 = simple_input(\"Please choose a command from the list to see errors: \", _current_err)\n\n elif cmd_call in ['csv', 'remap', 'fhir', 'json']:\n # Format: [File] [Output]\n if not self.inputs['loaded']:\n print(\"No Files Loaded!\\nYou Must load a file containing local medications first\")\n else:\n _file_opts = list(self.inputs['files'].keys()) + ['All']\n _dict_opts = list(smores.get_dict_sources(True)) #+ ['All']\n _file_or_dict = None\n\n if cmd_call in ['csv', 'json']:\n if len(args) == 0:\n _file_or_dict = simple_input(\"Do you want results for a File or a constructed Dictionary?\",\n ['File', 'Dictionary', 'exit'], True)\n elif args[0] not in _file_opts and args[0] not in _dict_opts:\n print('That option was not recognized as a valid source.')\n _file_or_dict = simple_input(\"Do you want results for a File or a constructed Dictionary?\",\n ['File', 'Dictionary', 'exit'], True)\n else:\n valid_1 = args[0]\n\n if _file_or_dict.upper() == 'FILE':\n valid_1 = 'FILE|' + simple_input(\"Please choose a loaded file\", _file_opts, True)\n\n elif _file_or_dict.upper() == 'DICTIONARY':\n valid_1 = 'DICT|' + simple_input(\"Please choose a code dictionary to output\", _dict_opts, True)\n elif _file_or_dict.upper() == 'EXIT':\n return None, None\n\n else:\n valid_1 = simple_input(\"Please choose a loaded file\", _file_opts, True)\n\n if cmd_call in ['csv', 'json', 'fhir']:\n if len(args) == 2 and len(args[1]) > 0:\n valid_2 = args[1]\n else:\n valid_2= input(\"Please provide an output file name:\").strip()\n\n if len(valid_2) > 0:\n if \".\" in valid_2:\n valid_2, ext = valid_2.split(\".\")\n else:\n valid_2 = ''\n print('Empty file name provided, using default.')\n else:\n valid_2 = args[0]\n\n elif cmd_call == 'file':\n re_use = False\n if self.inputs['loaded'] and len(in_args) == 0:\n print(\"The following file(s) have already been loaded: \\n\" + str(self.inputs['files']))\n _load_more = simple_input(\"Would you like to load an additional file?\", ['Y', 'N', 'exit'])\n if _load_more == 'Y':\n pass\n elif _load_more == 'N':\n _re_use = simple_input(\"Would you like to re-use a loaded file?\", ['Y', 'N', 'exit'])\n if _re_use == 'Y':\n re_use = True\n else:\n return False, None\n else:\n return False, None\n\n if in_args is not None and len(in_args) > 0:\n valid_1 = in_args\n else:\n valid_1 = input(\"Please enter the name of the file to load: \") if not re_use else simple_input(\n 'Select the file to be used: ', list(self.inputs['files'].keys()), index=True)\n\n while True:\n if valid_1 in self.inputs['files']:\n if not re_use:\n print(\"It looks like you've already loaded that file. Please try a different file.\")\n valid_1, valid_2 = input(\"Please enter the name of the file to load: \")\n else:\n break\n elif len(valid_1) == 0:\n smores_error('#Cx001.7', logger=smoresLog)\n valid_1, valid_2 = input(\"Please enter the name of the file to load: \")\n else:\n break\n\n if not resolve_target_path(valid_1):\n valid_1, valid_2 = self.validate_args('', 'file')\n\n elif '.smr' in valid_1:\n if len(self.inputs['files']) > 0:\n print(\n 'It looks like you are trying to load a session, this will replace the current session and '\n 'all previous work.')\n _save = simple_input('Do you want to save the current session first?', ['Y', 'N', 'EXIT'])\n if _save == 'Y':\n smores.save_session(self.__version__)\n elif _save == 'EXIT':\n return False, None\n valid_2 = 'session'\n else:\n valid_2 = 'file'\n\n smoresLog.debug('Args: {0}, Validated as: {1}'.format(valid_1, valid_2))\n return valid_1, valid_2","def GetNativeOutputInfo(\r\n is_struct=False,\r\n featurizer_name=\"\",\r\n ):\r\n raise Exception(\"Abstract method\")","def _get_request_parser(self, operation):\n\n wpsrequest = self\n\n def parse_get_getcapabilities(http_request):\n \"\"\"Parse GET GetCapabilities request\n \"\"\"\n\n acceptedversions = _get_get_param(http_request, 'acceptversions')\n wpsrequest.check_accepted_versions(acceptedversions)\n\n def parse_get_describeprocess(http_request):\n \"\"\"Parse GET DescribeProcess request\n \"\"\"\n version = _get_get_param(http_request, 'version')\n wpsrequest.check_and_set_version(version)\n\n language = _get_get_param(http_request, 'language')\n wpsrequest.check_and_set_language(language)\n\n wpsrequest.identifiers = _get_get_param(\n http_request, 'identifier', aslist=True)\n\n def parse_get_execute(http_request):\n \"\"\"Parse GET Execute request\n \"\"\"\n version = _get_get_param(http_request, 'version')\n wpsrequest.check_and_set_version(version)\n\n language = _get_get_param(http_request, 'language')\n wpsrequest.check_and_set_language(language)\n\n wpsrequest.identifier = _get_get_param(http_request, 'identifier')\n wpsrequest.store_execute = _get_get_param(\n http_request, 'storeExecuteResponse', 'false')\n wpsrequest.status = _get_get_param(http_request, 'status', 'false')\n wpsrequest.lineage = _get_get_param(\n http_request, 'lineage', 'false')\n wpsrequest.inputs = get_data_from_kvp(\n _get_get_param(http_request, 'DataInputs'), 'DataInputs')\n wpsrequest.outputs = {}\n\n # take responseDocument preferably\n resp_outputs = get_data_from_kvp(\n _get_get_param(http_request, 'ResponseDocument'))\n raw_outputs = get_data_from_kvp(\n _get_get_param(http_request, 'RawDataOutput'))\n wpsrequest.raw = False\n if resp_outputs:\n wpsrequest.outputs = resp_outputs\n elif raw_outputs:\n wpsrequest.outputs = raw_outputs\n wpsrequest.raw = True\n # executeResponse XML will not be stored and no updating of\n # status\n wpsrequest.store_execute = 'false'\n wpsrequest.status = 'false'\n\n if not operation:\n raise MissingParameterValue('Missing request value', 'request')\n else:\n self.operation = operation.lower()\n\n if self.operation == 'getcapabilities':\n return parse_get_getcapabilities\n elif self.operation == 'describeprocess':\n return parse_get_describeprocess\n elif self.operation == 'execute':\n return parse_get_execute\n else:\n raise OperationNotSupported(\n 'Unknown request %r' % self.operation, operation)","def _process_operation(operation_pb):\n match = _OPERATION_NAME_RE.match(operation_pb.name)\n if match is None:\n raise ValueError('Operation name was not in the expected '\n 'format after instance creation.',\n operation_pb.name)\n location_id = match.group('location_id')\n operation_id = int(match.group('operation_id'))\n\n request_metadata = _parse_pb_any_to_native(operation_pb.metadata)\n operation_begin = _pb_timestamp_to_datetime(\n request_metadata.request_time)\n\n return operation_id, location_id, operation_begin","def test_decoding_method(self):\n data = service_call.encode_call(\"foo\", [42])\n name, params = service_call.decode_call(data)\n\n self.assertEqual(name, \"foo\")\n self.assertEqual(params, [42])","def GetInput(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def _extract_commands(self, data):\n version = data[6]\n if version > 1:\n raise CarError('only version 1 is supported')\n if data[8] == 1:\n if self.inputastext is None:\n self.inputastext = True\n if data[9] == 1:\n if self.outputastext is None:\n self.outputastext = True\n data = data[10:]\n data = struct.unpack('<' + 'I' * (len(data) // 4), data)\n commands = tuple((data[i], data[i + 1]) for i in range(3, len(data), 2))\n for x, a in filter(lambda x: x[0] in (GOTO, IF), commands):\n if a >= len(commands):\n raise CarError('code position out of scope')\n return commands, data[:3]","def traffic_statuscodes_requestresponsetype(self, **kwargs):\n url_path = 'traffic/statuscodes/requestresponsetype'\n self.logger.debug(f\"Get list of request-response types\")\n body = self._make_body(kwargs)\n return self._common_get(request_path=url_path, parameters=body)","def function_response_types(self) -> pulumi.Output[Optional[Sequence['EventSourceMappingFunctionResponseTypesItem']]]:\n return pulumi.get(self, \"function_response_types\")","def pre_get_operation(\n self,\n request: operations_pb2.GetOperationRequest,\n metadata: Sequence[Tuple[str, str]],\n ) -> Tuple[operations_pb2.GetOperationRequest, Sequence[Tuple[str, str]]]:\n return request, metadata","def pre_get_operation(\n self,\n request: operations_pb2.GetOperationRequest,\n metadata: Sequence[Tuple[str, str]],\n ) -> Tuple[operations_pb2.GetOperationRequest, Sequence[Tuple[str, str]]]:\n return request, metadata","def action_GetProtocolInfo(self, extract_returns=True):\n arguments = { }\n\n out_params = self._proxy_call_action(\"GetProtocolInfo\", arguments=arguments)\n\n rtn_args = out_params\n if extract_returns:\n rtn_args = [out_params[k] for k in (\"Source\", \"Sink\",)]\n if len(rtn_args) == 1:\n rtn_args = rtn_args[0]\n\n return rtn_args","def _find_collection_response(op: Operation) -> Tuple[int, Any]:\n for code, resp_model in op.response_models.items():\n if resp_model is None or resp_model is NOT_SET:\n continue\n\n model = resp_model.__annotations__[\"response\"]\n if is_collection_type(model):\n item_schema = get_collection_args(model)[0]\n return code, item_schema\n\n raise ConfigError(\n f'\"{op.view_func}\" has no collection response (e.g. response=List[SomeSchema])'\n )","def gen_proto_recv(signame, argname, typename, size, is_enum, is_struct, is_varlen):\n add_code = None\n wordoff = word_offset(signame, argname)\n if is_varlen:\n # Array. Logic is identical to send direction; copying\n # is done elsewhere, we just return an offset.\n # The offset's the same for send, so we don't need\n # to generate any code.\n proto_code = None\n copy_code = None\n signature = None\n else:\n signature = mangle_type(typename)\n if is_struct:\n proto_code = \"%s *%s\" % (typename, argname)\n copy_code = \" CCP_%s_%s_GET(pdu, %s);\" % (\n signame.upper(), argname.upper(), argname)\n else:\n proto_code = \"%s *%s\" % (typename, argname)\n cast = \"(%s)\" % (typename)\n copy_code = \" *%s = %sCCP_%s_%s_GET(pdu);\" % (\n argname, cast, signame.upper(), argname.upper())\n return (proto_code, copy_code, add_code, signature)","def gen_CRM(call_text, response_text):\n pass","def _format_call(value: ast3.Call, context: types.Context) -> typing.Text:\n\ttry:\n\t\treturn _format_call_horizontal(value, context)\n\texcept errors.NotPossible:\n\t\treturn _format_call_vertical(value, context)","def GetOutputType(self, response_type):\n if response_type == \"KML\":\n return \"xml\"\n return \"json\"","def _process_request(self, request):\n try:\n self._validate_rpc_request(request)\n except ValueError as err:\n return self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err, keep_null_id=True)\n\n id = request.get('id', None)\n\n try:\n method = getattr(rpc, request['method'])\n except AttributeError as err:\n return self._build_rpc_error(id, RpcErrors.METHOD_NOT_FOUND, err)\n\n try:\n params = request.get('params', None)\n if params is None:\n result = method()\n elif isinstance(params, list):\n result = method(*params)\n elif isinstance(params, dict):\n result = method(**params)\n\n return self._build_rpc_result(id, result)\n\n except TypeError as err:\n return self._build_rpc_error(id, RpcErrors.INVALID_PARAMS, err)\n except Exception as err:\n return self._build_rpc_error(id, RpcErrors.INTERNAL_ERROR, err)","def check_message_params(message : dict) -> (bool, dict):\n logging.info('CHECKING message: '+str(message))\n\n data_tag = 'data'\n chat_data_tag = 'chat-data'\n param_tag = 'sessionJson'\n\n if data_tag in message:\n #Send the 'data' from the input to be checked\n extracted_params = parse_chat_input(message[data_tag]) #returns {choice, chat-data or None}\n logging.info('INPUT PARAMS:'+str(extracted_params))\n\n if extracted_params is None:\n logging.info('Missing (input param data) from protocol message')\n else:\n if 'choice' not in extracted_params or chat_data_tag not in extracted_params:\n logging.info('Missing (choice AND/OR data) in protocol message')\n else:\n choice = extracted_params.pop('choice')\n if choice == 1:\n return (choice, check_login_message(extracted_params))\n if choice == 2:\n #Add the session data back onto the result\n extracted_params.update(message[param_tag])\n return (choice, check_chat_message(extracted_params))\n if choice == 3:\n return (choice, (True, None))\n return (-1, (None, None))","def process_all_call_arg(self, code, option):\n return code","def from_output(cls, output: bytes, method: Method):\n s = None\n if b\"=====ERROR=====\" in output:\n s = cls.ERROR\n elif b\"=====UNKNOWN=====\" in output:\n s = cls.UNKNOWN\n elif b\"=====UNSATISFIABLE=====\" in output:\n s = cls.UNSATISFIABLE\n elif (\n b\"=====UNSATorUNBOUNDED=====\" in output or b\"=====UNBOUNDED=====\" in output\n ):\n s = cls.UNBOUNDED\n elif method is Method.SATISFY:\n if b\"==========\" in output:\n s = cls.ALL_SOLUTIONS\n elif b\"----------\" in output:\n s = cls.SATISFIED\n else:\n if b\"==========\" in output:\n s = cls.OPTIMAL_SOLUTION\n elif b\"----------\" in output:\n s = cls.SATISFIED\n return s","def process_check_protocol_callback(data):\n signature = data.get('signature')\n if not signature:\n return {'error': 'missing signature'}\n try:\n task = AnalysisTask.objects.get(id=signature)\n except AnalysisTask.DoesNotExist:\n return {'error': 'invalid signature'}\n\n entity = task.entity\n version = task.version\n task.delete() # So it can be re-run later if desired, and keep the table small\n\n if 'returntype' not in data:\n return {'error': 'missing returntype'}\n success = data['returntype'] == 'success'\n\n if success:\n # Store protocol interface in the repocache\n if 'required' not in data or 'optional' not in data or 'ioputs' not in data:\n return {'error': 'missing terms'}\n cached_version = entity.repocache.get_version(version)\n cached_version.parsed_ok = True\n cached_version.interface.all().delete() # Remove results of any previous analysis\n cached_version.save()\n terms = [\n ProtocolInterface(protocol_version=cached_version, term=term, optional=False)\n for term in data['required']\n ] + [\n ProtocolInterface(protocol_version=cached_version, term=term, optional=True)\n for term in data['optional']\n ]\n try:\n ProtocolInterface.objects.bulk_create(terms)\n except IntegrityError as e:\n return {'error': 'duplicate term provided: ' + str(e)}\n kinds = {name: value for value, name in ProtocolIoputs.KIND_CHOICES}\n ioputs = [\n ProtocolIoputs(\n protocol_version=cached_version,\n name=ioput['name'],\n units=ioput['units'],\n kind=kinds[ioput['kind']])\n for ioput in data['ioputs']\n ]\n # Store a flag so we know the interface has been analysed\n ioputs.append(ProtocolIoputs(protocol_version=cached_version, name=' ', kind=ProtocolIoputs.FLAG))\n try:\n ProtocolIoputs.objects.bulk_create(ioputs)\n except IntegrityError as e:\n return {'error': 'duplicate input or output provided: ' + str(e)}\n else:\n # Store error message as an ephemeral file\n error_message = data.get('returnmsg', '').replace('
', '\\n')\n if not error_message:\n return {'error': 'no error message supplied'}\n commit = entity.repo.get_commit(version)\n\n if ERROR_FILE_NAME in commit.filenames:\n logger.warning('Error file already exists in commit. New error message is: %s', error_message)\n else:\n content = b'Error analysing protocol:\\n\\n' + error_message.encode('UTF-8')\n commit.add_ephemeral_file(ERROR_FILE_NAME, content)\n # Don't try to analyse this protocol again\n cached_version = entity.repocache.get_version(version)\n cached_version.parsed_ok = False\n cached_version.save()\n ProtocolIoputs(protocol_version=cached_version, name=' ', kind=ProtocolIoputs.FLAG).save()\n\n return {}","def test_get_request_output(self):\n pass","def _process_convert_output_(self, output_data, **kwargs):\n accept_input, current_state, output = output_data\n if kwargs['full_output']:\n if current_state.label() is None:\n return (accept_input, current_state, None)\n else:\n return (accept_input, current_state, output)\n else:\n if not accept_input:\n return None\n return output","def _process_convert_output_(self, output_data, **kwargs):\n accept_input, current_state, output = output_data\n return (accept_input, current_state, output)","def post_call(self, date='2014-02-12', time='22:20:33', rnumber='0674767730', rname='Romain', snumber='0617382221', sname='Lolo'):\n xmldata1 = \"\" + \\\n \"\" + \\\n \"\" + \\\n \"\" + \\\n \"text/xml \" + \\\n \"call \" + \\\n \"\" + \\\n \"<Category>Incoming Call</Category>\" + \\\n \"<DisplayType>Maximum</DisplayType>\" + \\\n \"<CallTime>\" + \\\n \"<Date>\"\n xmldata2 = \"</Date>\" + \\\n \"<Time>\"\n xmldata3 = \"</Time>\" + \\\n \"</CallTime>\" + \\\n \"<Callee>\" + \\\n \"<Number>\"\n xmldata4 = \"</Number>\" + \\\n \"<Name>\"\n xmldata5 = \"</Name>\" + \\\n \"</Callee>\" + \\\n \"<Caller>\" + \\\n \"<Number>\"\n xmldata6 = \"</Number>\" + \\\n \"<Name>\"\n xmldata7 = \"</Name>\" + \\\n \"</Caller>\" + \\\n \" \" + \\\n \" \" + \\\n \" \" + \\\n \" \"\n\n #Create Header for Message\n header = \"POST /PMR/control/MessageBoxService HTTP/1.0\\r\\n\" + \\\n \"Content-Type: text/xml; charset=\\\"utf-8\\\"\\r\\n\" + \\\n \"Host: \" + self.host + \"\\r\\n\" + \\\n \"Content-Length: \" + str(len(xmldata1) + len(date) + \\\n len(xmldata2) + len(time) + \\\n len(xmldata3) + len(rnumber) + \\\n len(xmldata4) + len(rname) + \\\n len(xmldata5) + len(snumber) + \\\n len(xmldata6) + len(sname) + \\\n len(xmldata7)) + \"\\r\\n\" + \\\n \"SOAPACTION: urn:samsung.com:service:MessageBoxService:1#AddMessage\\r\\n\" + \\\n \"Connection: close\\r\\n\\r\\n\"\n #Create socket\n full_soap_request = header + \\\n xmldata1 + date + \\\n xmldata2 + time + \\\n xmldata3 + rnumber + \\\n xmldata4 + rname + \\\n xmldata5 + snumber +\\\n xmldata6 + sname +\\\n xmldata7\n msg_port = 52235;\n\n try:\n # Open Socket\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n sock.connect((self.host, msg_port))\n sock.send(full_soap_request.encode('utf-8'))\n read = sock.recv(1024)\n # print(\"\\n\\n Reader \\n\\n\" + read)\n sock.close()\n except socket.error, e:\n raise TVError(e[1], 'post_call')\n finally:\n sock.close()\n sock = None","def get_net_context(self, net):\n inputs = []\n outputs = []\n in_cons = []\n out_cons = []\n\n for con in self.connections:\n if net == self.connections[con].input:\n outputs += [self.connections[con].output]\n in_cons += [con]\n if net == self.connections[con].output:\n inputs += [self.connections[con].input]\n out_cons += [con]\n\n return inputs, in_cons, out_cons, outputs","def get_info_on_inputs(named_inputs, n_unnamed_inputs):\r\n n_named_inputs = len(named_inputs)\r\n\r\n def get_plural(n):\r\n if n > 1:\r\n return 's'\r\n else:\r\n return ''\r\n\r\n if n_named_inputs == 0:\r\n if n_unnamed_inputs == 0:\r\n msg = 'The function is supposed to have no input.'\r\n else:\r\n if n_unnamed_inputs == 1:\r\n msg = (\"The function has a single input variable which has no \"\r\n \"name, and thus cannot be assigned through a keyword\"\r\n \" argument (use 'name=...' in a Variable's \"\r\n \"constructor to give it a name).\")\r\n else:\r\n # Use plural.\r\n msg = (\"The function has %s inputs, but none of them is named,\"\r\n \" and thus they cannot be assigned through keyword \"\r\n \"arguments (use 'name=...' in a Variable's \"\r\n \"constructor to give it a name).\" % n_unnamed_inputs)\r\n else:\r\n if n_unnamed_inputs == 0:\r\n msg = (\"The function has %s named input%s (%s).\" % (\r\n n_named_inputs, get_plural(n_named_inputs),\r\n ', '.join(named_inputs)))\r\n else:\r\n msg = (\"The function has %s named input%s (%s), and %s unnamed \"\r\n \"input%s which thus cannot be accessed through keyword \"\r\n \"argument%s (use 'name=...' in a variable's constructor \"\r\n \"to give it a name).\" % (\r\n n_named_inputs, get_plural(n_named_inputs),\r\n ', '.join(named_inputs), n_unnamed_inputs,\r\n get_plural(n_unnamed_inputs),\r\n get_plural(n_unnamed_inputs)))\r\n return msg","def response_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"response_types\")","def response_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"response_types\")","def _parse_output_request(self, req):\n\n output_request = self._output_request_type_check(req)\n\n for request in output_request:\n if request not in self.OUT_ATTRS:\n msg = ('User output request \"{}\" not recognized. '\n 'Will attempt to extract from PySAM.'.format(request))\n logger.debug(msg)\n\n modules = []\n for request in output_request:\n if request in self.OPTIONS:\n modules.append(self.OPTIONS[request])\n\n if not any(modules):\n msg = ('None of the user output requests were recognized. '\n 'Cannot run reV econ. '\n 'At least one of the following must be requested: {}'\n .format(list(self.OPTIONS.keys())))\n logger.exception(msg)\n raise ExecutionError(msg)\n\n b1 = [m == modules[0] for m in modules]\n b2 = np.array([m == WindBos for m in modules])\n b3 = np.array([m == SingleOwner for m in modules])\n\n if all(b1):\n self._sam_module = modules[0]\n self._fun = modules[0].reV_run\n elif all(b2 | b3):\n self._sam_module = SingleOwner\n self._fun = SingleOwner.reV_run\n else:\n msg = ('Econ outputs requested from different SAM modules not '\n 'currently supported. Output request variables require '\n 'SAM methods: {}'.format(modules))\n raise ValueError(msg)\n\n return list(set(output_request))","def _call(self, name, *args, **kwargs):\r\n if len(args) and len(kwargs):\r\n raise TypeError(\r\n 'Use positional or keyword argument only.'\r\n )\r\n\r\n callinfo = getattr(self, name).callinfo\r\n soapAction = callinfo.soapAction\r\n url = callinfo.location\r\n (protocol, host, uri, query, fragment, identifier) = urlparse(url)\r\n port = '80'\r\n if host.find(':') >= 0:\r\n host, port = host.split(':')\r\n\r\n binding = Binding(host=host, tracefile=self._tracefile,\r\n ssl=(protocol == 'https'),\r\n port=port, url=None, typesmodule=self._typesmodule,\r\n nsdict=self._nsdict, soapaction=self._soapAction,\r\n ns=self._ns, op_ns=self._op_ns)\r\n\r\n if self._use_wsdl:\r\n request, response = self._getTypeCodes(callinfo)\r\n if len(kwargs): args = kwargs\r\n if request is None:\r\n request = Any(oname=name)\r\n binding.Send(url=uri, opname=None, obj=args,\r\n nsdict=self._nsdict, soapaction=soapAction, requesttypecode=request)\r\n return binding.Receive(replytype=response)\r\n\r\n apply(getattr(binding, callinfo.methodName), args)\r\n\r\n return binding.Receive()","def rpc_info():","def validate_input(request):\n\n # Validate errors inputs\n request_data = JSONParser().parse(request)\n\n if 'action' not in request_data:\n return_data = {'error': 'No action'}\n logger.error('validate_input method: error:{} request:{}'.format(return_data, request))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n if 'east' not in request_data:\n return_data = {'error': 'No east'}\n logger.error('validate_input method: error:{} request:{}'.format(return_data, request))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n if 'west' not in request_data:\n return_data = {'error': 'No west'}\n logger.error('validate_input method: error:{} request:{}'.format(return_data, request))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n # Debug mode checking condition\n if 'number' in request_data and 'stops' in request_data:\n\n # If current status is break then making debug mode\n if ValidateError.check_current_status() == 'break':\n return CreateDebugMode.validate_input_to_create_debug_mode(request_data)\n\n # If current status is started or pending then return error_robotworking message\n elif ValidateError.check_current_status() in ['started', 'pending']:\n return_data = {'status': 'error', 'error': 'robotworking'}\n logger.error('validation_errors.check_current_status debug mode method: error:robotworking request:{}'\n .format(request_data))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n # Else return error_status message\n else:\n return_data = {'status': 'error', 'error': 'status'}\n logger.error('validation_errors.check_current_status debug mode method: error:status unknown request:{}'\n .format(request_data))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n # Disconnection checking condition\n elif request_data['action'] == 'disconnect':\n\n # If current status is success or revoked or no_uuid then making disconnection\n if ValidateError.check_current_status() in ['success', 'revoked', 'no_uuid', 'failure']:\n return CreateDisconnect.validate_input_to_create_disconnection(request_data)\n\n # If current status is started or pending or break then return error_robotworking message\n elif ValidateError.check_current_status() in ['started', 'pending', 'break']:\n return_data = {'status': 'error', 'error': 'robotworking'}\n logger.error('validation_errors.check_current_status disconnection method: '\n 'error:robotworking request:{}'.format(request_data))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n # Else return error_status message\n else:\n return_data = {'status': 'error', 'error': 'status'}\n logger.error('validation_errors.check_current_status disconnection method:'\n ' error:status unknown request:{}'.format(request_data))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n # Connection checking condition\n elif request_data['action'] == 'connect':\n\n # If current status is success or revoked or no_uuid then making connection\n if ValidateError.check_current_status() in ['success', 'revoked', 'no_uuid', 'failure']:\n return CreateConnection.validate_input_to_create_connection(request_data)\n\n # If current status is started or pending or break then return error_robotworking message\n elif ValidateError.check_current_status() in ['started', 'pending', 'break']:\n return_data = {'status': 'error', 'error': 'robotworking'}\n logger.error('validation_errors.check_current_status connection method: error:robotworking request:{}'\n .format(request_data))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n # Else return error_status message\n else:\n return_data = {'status': 'error', 'error': 'status unknown'}\n logger.error('validation_errors.check_current_status connection method: error:status request:{}'\n .format(request_data))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\n\n # Create connection in connection table\n elif request.data['action'] == 'create_connection':\n return ConnectionUtilities.create_dummy_connection(request_data)\n\n # Else return error_operation message\n else:\n return_data = {'status': 'error', 'error': 'operation'}\n logger.error('validation_errors.check_current_status connection method: error:action unknown request:{}'\n .format(request_data))\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)","def _handle_info_response(self, resp, info, prev_info):\r\n if info.line_num != prev_info.line_num:\r\n return\r\n\r\n if resp['calltip']:\r\n info.editor.show_calltip('Arguments', resp['calltip'],\r\n signature=True,\r\n at_position=prev_info.position)\r\n\r\n if resp['name']:\r\n self.send_to_inspector.emit(\r\n resp['name'], resp['argspec'],\r\n resp['note'], resp['docstring'],\r\n not prev_info.auto)","def valid_properties(self) -> Tuple[str]:\n tt = self.transaction_type\n if tt == \"GENESIS\":\n return (\n \"token_type\",\n \"transaction_type\",\n \"lokad_id\",\n \"nft_flag\",\n \"ticker\",\n \"token_name\",\n \"token_doc_url\",\n \"token_doc_hash\",\n \"decimals\",\n \"mint_baton_vout\",\n \"initial_token_mint_quantity\",\n )\n elif tt == \"MINT\":\n return (\n \"token_type\",\n \"transaction_type\",\n \"lokad_id\",\n \"nft_flag\",\n \"token_id\",\n \"token_id_hex\",\n \"mint_baton_vout\",\n \"additional_token_quantity\",\n )\n elif tt == \"SEND\":\n return (\n \"token_type\",\n \"transaction_type\",\n \"lokad_id\",\n \"nft_flag\",\n \"token_id\",\n \"token_id_hex\",\n \"token_output\",\n )\n elif tt == \"COMMIT\":\n return (\n \"token_type\",\n \"transaction_type\",\n \"lokad_id\",\n \"nft_flag\",\n \"info\",\n )\n raise InvalidOutputMessage(\"Unknown transaction_type\", tt)","def InfoCall(connection, functionno, rc):\n\n ssl_logging = logging.getLogger('SSL_InfoCall')\n\n ssl_logging.debug('In InfoCall')\n ssl_logging.debug('State : %s' % connection.state_string())\n ssl_logging.debug('Fuction Number: %s' % functionno)\n ssl_logging.debug('Return Code : %s' % rc)\n return 0","def response_types(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"response_types\")","def get_input_output_args(io_info):\n args = []\n if io_info is None:\n return args\n for item in io_info:\n if isinstance(item, dict):\n arg = get_single_io_arg(item)\n args.append(arg)\n elif isinstance(item, list):\n dyn_arg = []\n for info in item:\n arg = get_single_io_arg(info)\n dyn_arg.append(arg)\n args.append(tuple(dyn_arg))\n return args","def get_input(incoming):\n try:\n return incoming.get_output, incoming.get_output_shape()\n except AttributeError:\n return lambda **kwargs: incoming, [d if isinstance(d, int) else -1 for d in incoming.get_shape().as_list()]","def GetInputCount(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def handle_request(self, query, request):\r\n request_pdu = None\r\n response_pdu = \"\"\r\n slave_id = None\r\n function_code = None\r\n func_code = None\r\n slave = None\r\n response = None\r\n\r\n try:\r\n # extract the pdu and the slave id\r\n slave_id, request_pdu = query.parse_request(request)\r\n if len(request_pdu) > 0:\r\n (func_code, ) = struct.unpack(\">B\", request_pdu[0])\r\n # 43 is Device Information\r\n if func_code == 43:\r\n # except will throw MissingKeyError\r\n slave = self.get_slave(slave_id)\r\n response_pdu = slave.handle_request(request_pdu)\r\n # make the full response\r\n response = query.build_response(response_pdu)\r\n # get the slave and let him execute the action\r\n elif slave_id == 0:\r\n # broadcast\r\n for key in self._slaves:\r\n response_pdu = self._slaves[key].handle_request(request_pdu, broadcast=True)\r\n response = query.build_response(response_pdu)\r\n elif slave_id == 255:\r\n r = struct.pack(\">BB\", func_code + 0x80, 0x0B)\r\n response = query.build_response(r)\r\n else:\r\n slave = self.get_slave(slave_id)\r\n response_pdu = slave.handle_request(request_pdu)\r\n # make the full response\r\n response = query.build_response(response_pdu)\r\n except (IOError, MissingKeyError) as e:\r\n # If the request was not handled correctly, return a server error response\r\n r = struct.pack(\">BB\", func_code + 0x80, defines.SLAVE_DEVICE_FAILURE)\r\n response = query.build_response(r)\r\n\r\n if slave:\r\n function_code = slave.function_code\r\n\r\n return (response, {'request': request_pdu.encode('hex'),\r\n 'slave_id': slave_id,\r\n 'function_code': function_code,\r\n 'response': response_pdu.encode('hex')})","def get_req_data(self, data):\n self.rdata=data\n if self.rdata == 1 or \\\n self.rdata == 0 or \\\n self.rdata == \"\":\n return 1\n rt=\"\"\n for ot in self.rdata.split('\\n'):\n ot = ot.rstrip('\\r\\n')\n logging.debug(\">>>>>>> Check value of output string: %s\" % ot)\n if not (ot.startswith(\"vRA \") or \\\n ot.startswith(\"JRE Version:\") or \\\n ot.startswith(\"CloudClient is \") or \\\n ot.startswith(\"true\") or \\\n len(ot) == 0):\n if ot.startswith(\"Error\"):\n print (\"Error: %s\" % ot.split('Error')[-1])\n sys.stdout.flush()\n sys.exit(1)\n else:\n logging.debug(\"SR# %s\" % ot)\n rt=ot\n break\n if not rt:\n print \"No service request is found: %s\" % rt\n return 1\n else:\n return rt","def command_type(self):\n if self._is_push_command():\n command_type = Parser.C_PUSH\n elif self._is_pop_command():\n command_type = Parser.C_POP\n elif self._is_arithmetic_command():\n command_type = Parser.C_ARITHMETIC\n elif self._is_comment_line() or self._is_blank_line():\n command_type = Parser.IGNORE\n else:\n command_type = Parser.INVALID\n return command_type","def oic_pre_construct(self, cli_info, request_args=None, **kwargs):\n for prop in self.msg_type.c_param.keys():\n if prop in request_args:\n continue\n try:\n request_args[prop] = cli_info.behaviour[prop]\n except KeyError:\n pass\n\n if \"post_logout_redirect_uris\" not in request_args:\n try:\n request_args[\n \"post_logout_redirect_uris\"] = \\\n cli_info.post_logout_redirect_uris\n except AttributeError:\n pass\n\n if \"redirect_uris\" not in request_args:\n try:\n request_args[\"redirect_uris\"] = cli_info.redirect_uris\n except AttributeError:\n raise MissingRequiredAttribute(\"redirect_uris\", request_args)\n\n try:\n if cli_info.provider_info[\n 'require_request_uri_registration'] is True:\n request_args['request_uris'] = cli_info.generate_request_uris(\n cli_info.requests_dir)\n except KeyError:\n pass\n\n return request_args, {}","def RequestInformation(self, request, inInfoVec, outInfoVec):\n from vtkmodules.vtkCommonExecutionModel import vtkStreamingDemandDrivenPipeline as sddp\n\n iin = inInfoVec[1].GetInformationObject(0)\n outInfoVec.GetInformationObject(0).Set(sddp.WHOLE_EXTENT(), iin.Get(sddp.WHOLE_EXTENT()), 6);\n return 1","def get_decoding_op(self):\n return self._dual.get_op('output')","def _check_validconnectioninput(self):\n # Check if name is valid\n if self._check_name(self.symbol):\n second_device = self.symbol\n self.symbol = self.scanner.get_symbol()\n # Check if '.' is used:\n if self._is_period(self.symbol):\n self.symbol = self.scanner.get_symbol()\n # Check if device input begins with 'I'\n if self.names.get_name_string(self.symbol.id)[0] == \"I\":\n # Check if input number is a positive number\n try:\n inputno = int(\n self.names.get_name_string(\n self.symbol.id)[\n 1:])\n second_port = self.symbol\n self.symbol = self.scanner.get_symbol()\n return second_device, second_port\n except BaseException:\n # Input number is not valid\n self._display_syntax_error(\"number\")\n self._semicolon_skipper()\n return None, None\n # OR if DType input\n elif self._check_validdtypeinput(self.symbol):\n second_port = self.symbol\n self.symbol = self.scanner.get_symbol()\n return second_device, second_port\n else:\n # Input is not valid\n self._display_syntax_error(\"input\")\n self._semicolon_skipper()\n return None, None\n else:\n # No '.'\n self._display_syntax_error(\"period\")\n self._semicolon_skipper()\n return None, None\n else:\n # Device does not exist\n self._display_syntax_error(\"devicename\")\n self._semicolon_skipper()\n return None, None","def write_operation_type(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"write_operation_type\")","def write_operation_type(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"write_operation_type\")","def write_operation_type(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"write_operation_type\")","def write_operation_type(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"write_operation_type\")","def print_results(request, response, procedure_name) -> None:\n procedure_names_dict = {\n 'SquareRoot': calculator_pb2_grpc.CalculatorServicer.SquareRoot.__name__,\n 'Square': calculator_pb2_grpc.CalculatorServicer.Square.__name__,\n }\n print_string = f\"Request: {procedure_names_dict[procedure_name]} for {request.value}.\\nResponse: {response.value}.\\n\"\n print(print_string)","def status_determine():\n b_status = False\n b_statusInput = True\n b_statusAnalyze = True\n b_statusOutput = True\n nonlocal dret_inputSet\n nonlocal dret_analyze\n nonlocal dret_outputSet\n nonlocal fn_inputReadCallback\n nonlocal fn_analysisCallback\n nonlocal fn_outputWriteCallback\n\n if fn_inputReadCallback:\n if 'status' in dret_inputSet.keys():\n b_statusInput = dret_inputSet['status']\n if fn_analysisCallback:\n if 'status' in dret_analyze.keys():\n b_statusAnalyze = dret_analyze['status']\n if fn_outputWriteCallback:\n if 'status' in dret_outputSet.keys():\n b_statusOutput = dret_outputSet['status']\n\n b_status = b_statusInput and b_statusAnalyze and b_statusOutput\n return {\n 'status': b_status\n }","def _dispatch(self, request):\n endpoint, values, context, param = self.read_request(request)\n if endpoint == 'init':\n parse_config(param.get('config', {}))\n return self.init_info()\n else:\n if endpoint == 'provider':\n return self.call_provider(context, values['name'],\n values['action'], param)\n elif endpoint == 'handler':\n return self.call_handler(context, values['name'], param)\n else:\n return self.call_func(context, endpoint, values['name'], param)","def call(self, inputs, training=False):\n prev_merge_mode = self.merge_mode\n self.set_merge_mode('merge')\n enc_outputs = self.call_encoder(inputs, training)\n dec_outputs = self.call_decoder(enc_outputs, training)\n self.set_merge_mode(prev_merge_mode)\n\n return dec_outputs","def map_operation(**kwargs):\n operation = kwargs.get(\"data\", \"\")\n operation_mapper = {\"POST\": \"CREATE\"}\n return operation_mapper.get(operation, operation)","def input_or_output(self):\n return \"I\"","def call(self, inputs):\n raise NotImplementedError","def input_type():\n pass","def _call(*,\n call,\n method,\n headers,\n params=None,\n data=None,\n no_headers=False,\n json_output=True,\n raw=False,\n **kwargs):\n if not headers and not data and not params and not no_headers:\n raise AttributeError(\n 'Asked to do a call to the cloud without valid headers, data or params. This would never work.'\n )\n\n try:\n if method is requests.put:\n if data:\n response = method(call, headers=headers, data=data, timeout=5)\n else:\n raise AttributeError('PUT call with no data, this would fail!')\n elif method is requests.post:\n if data and params:\n response = method(call, headers=headers, data=data, params=params, timeout=5)\n elif data:\n response = method(call, headers=headers, data=data, timeout=5)\n elif params:\n response = method(call, headers=headers, params=params, timeout=5)\n else:\n raise AttributeError(\n 'POST call with no data or params, this probably makes no sense!')\n\n elif params:\n response = method(call, headers=headers, params=params, timeout=5)\n else:\n response = method(call, headers=headers, timeout=5)\n\n except requests.exceptions.RequestException as e: # pragma: no cover\n raise ConnectionError(str(e)) from None\n\n if response.status_code == 200:\n if raw:\n return response\n if json_output:\n return response.json()\n else:\n return response.text\n\n elif response.status_code == 410: # pragma: no cover\n raise APIError(\n response.status_code,\n 'API version outdated. Update python-cozify. {reason} - {url} - {message}'.format(\n reason=response.reason, url=response.url, message=response.text))\n else: # pragma: no cover\n raise APIError(\n response.status_code, '{reason} - {url} - {message}'.format(reason=response.reason,\n url=response.url,\n message=response.text))","def external_call( d, output, stack, context ):\n\targuments = d[\"args\"].split(\" \")\n\tstack_collect = stack[-len(arguments):]\n\tfor arg, desired in zip(stack_collect, arguments):\n\t\tresult = type_system.type_reduce( arg, desired, output, stack, context )\n\t\tif result != \"success\":\n\t\t\treturn \"pass\"\n\toutput.append(\" call %s\\n\" % d[\"name\"])\n\tfor i in arguments:\n\t\tstack.pop()\n\tretvals = d[\"ret\"].split(\" \")\n\tfor val in retvals:\n\t\tstack.append( type_system.Datum( [[val]], [None] ) )\n\treturn \"success\"","def form_translate(input_data, operation):\n \n # In case you're trying to produce this behavior on the command line for\n # rapid testing, the command that eventually gets called is: \n # java -jar form_translate.jar < form.xml > output\n #\n # You can pass in a filename or a full string/stream of xml data\n p = subprocess.Popen([\"java\",\"-jar\",\n config.FORM_TRANSLATE_JAR_LOCATION,\n operation], \n shell=False, \n stdout=subprocess.PIPE,\n stdin=subprocess.PIPE,\n stderr=subprocess.PIPE)\n p.stdin.write(input_data)\n p.stdin.flush()\n p.stdin.close()\n \n output = p.stdout.read() \n error = p.stderr.read()\n \n # todo: this is horrible.\n has_error = \"exception\" in error.lower() \n \n return {\"success\": not has_error,\n \"errstring\": error,\n \"outstring\": output}","def _process_info_message(self, message):\n # Extract the output resolution from the appropriate message, if\n # it's present.\n contents = message.get('contents', None)\n if message['messageCode'] == 'JOB_RUNNING_RESOLUTION':\n self._resolution = contents['resolutionMs']\n elif message['messageCode'] == 'FETCH_NUM_TIMESERIES':\n self._num_input_timeseries += int(message['numInputTimeSeries'])\n elif message['messageCode'] == 'FIND_MATCHED_NO_TIMESERIES':\n self._find_matched_no_timeseries = True\n elif message['messageCode'] == 'FIND_LIMITED_RESULT_SET':\n self._find_limited_resultset = True\n self._find_matched_size = contents['matchedSize']\n self._find_limit_size = contents['limitSize']\n elif message['messageCode'] == 'GROUPBY_MISSING_PROPERTY':\n self._group_by_missing_property = True\n self._group_by_missing_properties = contents['propertyNames']","def SendOutputs(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def get_operation_obect(self, method):\n pass","def generate_interface_types(interface, name=None):\n\n if not isinstance(interface, type):\n interface = type(interface)\n\n module = interface.__module__\n\n method_signatures = {\n name: MethodSignature.from_method(getattr(interface, name))\n for name in classes.get_public_method_names(interface)\n }\n\n args_type, types, makers = make_args_type(module, method_signatures)\n request_type = dataclasses.make_dataclass(\n (name or interface.__name__) + 'Request',\n [('args', args_type)],\n namespace={\n 'Args': args_type,\n 'types': types,\n 'm': makers,\n },\n frozen=True,\n )\n request_type.__module__ = module\n\n result_type = make_result_type(module, method_signatures)\n error_type = make_error_type(module, interface, method_signatures)\n response_type = dataclasses.make_dataclass(\n (name or interface.__name__) + 'Response',\n [\n (\n 'result',\n typing.Optional[result_type],\n dataclasses.field(default=None),\n ),\n (\n 'error',\n typing.Optional[error_type],\n dataclasses.field(default=None),\n ),\n ],\n namespace={\n 'Result': result_type,\n 'Error': error_type,\n },\n frozen=True,\n )\n response_type.__module__ = module\n\n return request_type, response_type","def parse_operations(self, operation_type: str) -> Tuple[Operation]:\n if operation_type is None:\n return tuple()\n query_type: SchemaType = self.types.get(operation_type)\n if query_type is None:\n return tuple()\n return tuple([Operation(f, self.settings) for f in query_type.fields])","def full_dispatch_request(self):\n fn = getattr(self, g.action, None)\n if fn is None:\n abort(404, 'Unimplemented action %r' % g.action)\n inputs = self.__class__.schema_inputs.get(g.action)\n outputs = self.__class__.schema_outputs.get(g.action)\n output_types = self.__class__.output_types\n if inputs is not None:\n (errors, values) = validate(g.request_data, inputs)\n if errors:\n return dict(errors), 400\n else:\n if isinstance(values, dict):\n rv = fn(**values)\n else:\n rv = fn(values)\n else:\n rv = fn()\n rv, code, headers = unpack(rv)\n if outputs is not None:\n (errors, values) = validate(rv, outputs, proxy_types=output_types)\n if errors:\n return dict(errors), 500\n else:\n rv = values\n return rv, code, headers","def PostInputsNiFi(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def __show_protocol__(self, data):\n t_16 = t_16_Bit_Options()\n t_8 = t_8_Bit_Options()\n t_var = t_8_Bit_Options()\n print('Received ' + str(len(data)) + ' Bytest')\n\n #----------------------------------------------------------------------\n print('='*80)\n print('Handling Protocol response: ' + hexlify(data))\n #----------------------------------------------------------------------\n print('='*80)\n print('Overhead Bytes: ' + hexlify(data[:BP_TOOL.OVERHEAD]))\n print('Number of UINT16 bitstream data = ' + str(data[BP_TOOL.UINT16S]))\n print('Number of UINT8 bitstream data = ' + str(data[BP_TOOL.UINT8S]))\n print('Number of var bitstream data = ' + str(data[BP_TOOL.VARS]))\n print('Follow = ' + str(self.get_follow(data)))\n print('Length = ' + str(self.get_length(data)))\n start = self.get_follow_and_length(data)\n end = start + BP_TOOL.SIZE_FOLLOW + BP_TOOL.SIZE_LEN\n print('Following bytes and length = ' + hexlify(data[start:end]))\n #----------------------------------------------------------------------\n print('='*80)\n bits = self.get_16bit_options_bits(data)\n values = self.get_16bit_options(data)\n options = self.get_options_requested(bits)\n\n # Display the options if exist\n if len(options):\n print('UINT16 bits...... : ' + hexlify(bits))\n print('UINT16 data...... : ' + hexlify(values))\n print('UINT16 Num of opts ... : ' + str(len(values) // 2))\n print('UINT16 options... : ' + str(options))\n print('-'*80)\n for x in range(len(options)):\n value = (values[x*2] << 8) | (values[x*2 + 1])\n opt = options[x]\n t_16.set_value(opt, value)\n print('Option: ' + t_16.options[opt]['name'] + ' ' + str(value))\n pprint.pprint(t_16.options)\n else:\n print('No 16 bit options')\n\n #----------------------------------------------------------------------\n print('-'*80)\n bits = self.get_8bit_options_bits(data)\n values = self.get_8bit_options(data)\n options = self.get_options_requested(bits)\n # Display the options if exist\n if len(options):\n print('UINT8 bits...... : ' + hexlify(bits))\n print('UINT8 data...... : ' + hexlify(values))\n print('UINT8 options... : ' + str(options))\n print('-'*80)\n for x in range(len(options)):\n value = values[x]\n opt = options[x]\n t_8.set_value(opt, value)\n print('Option: ' + t_8.options[x]['name'] + ' ' + str(value))\n pprint.pprint(t_8.options)\n else:\n print('No 8 bit options')\n\n #----------------------------------------------------------------------\n print('-'*80)\n bits = self.get_var_options_bits(data)\n values = self.get_var_options(data)\n print('VARS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')\n # Display the options if exist\n if len(values):\n pprint.pprint(values)\n else:\n print('No var bit options')\n\n print('VAR options... : ' + str(self.get_options_requested(bits)))\n print('VARS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')\n print('-'*80)","def _process_ok_response(self, bis, request):\n #\n # this call gives the Request an opinion on which serial version\n # to use\n #\n version = request.get_serial_version(self._client.serial_version)\n if version <= 3:\n # V3 and earlier protocols start with an error byte (0 is no error)\n code = bis.read_byte()\n else:\n # V4 starts with an NSON MAP. If the type is correct then treat it\n # as a V4 response. If it's not correct then it's a V3\n # error code from a V3 proxy. If it's a V4 map, code will be 0\n code = SerdeUtil.check_for_map(bis)\n if code == 0:\n res = request.create_serializer(version).deserialize(\n request, bis, version)\n if request.is_query_request():\n if not request.is_simple_query():\n request.get_driver().set_client(self._client)\n return res\n\n \"\"\"\n Operation failed. Handle the failure and throw an appropriate\n exception.\n \"\"\"\n err = SerdeUtil.read_string(bis)\n\n # special case for TNF errors on WriteMultiple with many tables\n if code == SerdeUtil.USER_ERROR.TABLE_NOT_FOUND and \\\n isinstance(request, operations.WriteMultipleRequest):\n raise self._handle_write_multiple_table_not_found(code, err, request)\n\n raise SerdeUtil.map_exception(code, err)","def parse_request(self, request):\n response=''\n http_code = 200\n\n request_line = request.splitlines()[0]\n request_method, path, request_version = request_line.split()\n\n #Try to split path into it's components: the operation requested and the keyvalue\n try:\n request_op, request_keyvalue = path.split('?')\n request_op = request_op[1:]\n\n #If request is a get we split in a different order than if it's a set\n if request_op == 'get':\n request_value, request_key = request_keyvalue.split('=')\n response, http_code = self.get_value(request_key)\n elif request_op == 'set':\n request_key, request_value = request_keyvalue.split('=')\n response, http_code = self.set_value(request_key, request_value)\n else:\n response = 'Unknown operation in URL. Must be either GET or SET.'\n http_code = 400\n\n except ValueError: #Catch any paths that don't match the form we're interested in\n response = dedent(\"\"\"Incorrect path (%s)\n Requested URL must take the form http://%s:%s/[operation]?[value]\"\"\" % (path, self.server_address, self.server_port))\n http_code = 400\n return response, http_code\n\n return response, http_code","def visit_Call(self, node: ast.Call) -> None:\n self._check_open_call_context(node)\n self._check_type_compare(node)\n self._check_range_len(node)\n self.generic_visit(node)","def check_request(self, params, permission):\n exception = {}\n\n if permission.get('qgs_project') is None:\n # service unknown or not permitted\n exception = {\n 'code': \"Service configuration error\",\n 'message': \"Service unknown or unsupported\"\n }\n elif not params.get('REQUEST'):\n # REQUEST missing or blank\n exception = {\n 'code': \"OperationNotSupported\",\n 'message': \"Please check the value of the REQUEST parameter\"\n }\n else:\n service = params.get('SERVICE', '')\n request = params.get('REQUEST', '').upper()\n\n if service == 'WMS' and request == 'GETFEATUREINFO':\n # check info format\n info_format = params.get('INFO_FORMAT', 'text/plain')\n if re.match('^application/vnd.ogc.gml.+$', info_format):\n # do not support broken GML3 info format\n # i.e. 'application/vnd.ogc.gml/3.1.1'\n exception = {\n 'code': \"InvalidFormat\",\n 'message': (\n \"Feature info format '%s' is not supported. \"\n \"Possibilities are 'text/plain', 'text/html' or \"\n \"'text/xml'.\"\n % info_format\n )\n }\n elif service == 'WMS' and request == 'GETPRINT':\n # check print templates\n template = params.get('TEMPLATE')\n if template and template not in permission['print_templates']:\n # allow only permitted print templates\n exception = {\n 'code': \"Error\",\n 'message': (\n 'Composer template not found or not permitted'\n )\n }\n\n if not exception:\n # check layers params\n\n # lookup for layers params by request\n # {\n # : {\n # : [\n # , \n # ]\n # }\n # }\n ogc_layers_params = {\n 'WMS': {\n 'GETMAP': ['LAYERS', None],\n 'GETFEATUREINFO': ['LAYERS', 'QUERY_LAYERS'],\n 'GETLEGENDGRAPHIC': [None, 'LAYER'],\n 'GETLEGENDGRAPHICS': [None, 'LAYER'], # QGIS legacy request\n 'DESCRIBELAYER': [None, 'LAYERS'],\n 'GETSTYLES': [None, 'LAYERS']\n },\n 'WFS': {\n 'DESCRIBEFEATURETYPE': ['TYPENAME', None],\n 'GETFEATURE': [None, 'TYPENAME']\n }\n }\n\n layer_params = ogc_layers_params.get(service, {}).get(request, {})\n\n if service == 'WMS' and request == 'GETPRINT':\n # find map layers param for GetPrint (usually 'map0:LAYERS')\n for key, value in params.items():\n if key.endswith(\":LAYERS\"):\n layer_params = [key, None]\n break\n\n if layer_params:\n permitted_layers = permission['public_layers']\n filename = params.get('FILENAME', '')\n if (service == 'WMS' and (\n (request == 'GETMAP' and filename) or request == 'GETPRINT'\n )):\n # When doing a raster export (GetMap with FILENAME)\n # or printing (GetPrint), also allow background layers\n permitted_layers += permission['background_layers']\n if layer_params[0] is not None:\n # check optional layers param\n exception = self.check_layers(\n layer_params[0], params, permitted_layers, False\n )\n if not exception and layer_params[1] is not None:\n # check mandatory layers param\n exception = self.check_layers(\n layer_params[1], params, permitted_layers, True\n )\n\n return exception","def _check_validconnectionoutput(self):\n # Check if name is valid and has been initialised\n if self._check_name(self.symbol):\n first_device = self.symbol\n self.symbol = self.scanner.get_symbol()\n # Check if '->' is used\n if self._is_arrow(self.symbol):\n return first_device, None\n elif self._is_period(self.symbol):\n self.symbol = self.scanner.get_symbol()\n if self._check_validdtypeoutput(self.symbol):\n first_port = self.symbol\n self.symbol = self.scanner.get_symbol()\n return first_device, first_port\n else:\n # Invalid DType output\n self._display_syntax_error(\"doutput\")\n self._semicolon_skipper()\n return None, None\n else:\n # Neither an arrow nor a DType output\n self._display_syntax_error(\"arrowperiod\")\n self._semicolon_skipper()\n return None, None\n else:\n # Device does not exist\n self._display_syntax_error(\"devicename\")\n self._semicolon_skipper()\n return None, None","def StreamInputs(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def guess_calling_convention(self):\n return calldef_types.CALLING_CONVENTION_TYPES.UNKNOWN","def getsolutioninfo(self,whichsol_): # 3\n if not isinstance(whichsol_,soltype): raise TypeError(\"Argument whichsol has wrong type\")\n res,resargs = self.__obj.getsolutioninfo(whichsol_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n _pobj_return_value,_pviolcon_return_value,_pviolvar_return_value,_pviolbarvar_return_value,_pviolcone_return_value,_pviolitg_return_value,_dobj_return_value,_dviolcon_return_value,_dviolvar_return_value,_dviolbarvar_return_value,_dviolcone_return_value = resargs\n return _pobj_return_value,_pviolcon_return_value,_pviolvar_return_value,_pviolbarvar_return_value,_pviolcone_return_value,_pviolitg_return_value,_dobj_return_value,_dviolcon_return_value,_dviolvar_return_value,_dviolbarvar_return_value,_dviolcone_return_value","def getOperationMetadata(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')"],"string":"[\n \"def GetModelOutputInfo(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def verify_call(obj):\\n\\tassert obj.tag == 'OMOBJ'\\n\\tattr = obj[0]\\n\\t\\n\\tassert attr.tag == 'OMATTR'\\n\\tpairs, application = attr\\n\\t\\n\\tassert application.tag == 'OMA'\\n\\tsymbol, args = application\\n\\t\\n\\tassert symbol.tag == 'OMS'\\n\\tassert symbol.get('cd') == \\\"scscp1\\\"\\n\\tassert symbol.get('name') == \\\"procedure_call\\\"\\n\\t\\n\\tassert args.tag == 'OMA'\\n\\tassert len(args) > 0\\n\\tname_symbol = args[0]\\n\\t\\n\\tassert name_symbol.tag == 'OMS'\\n\\tcd = name_symbol.get('cd')\\n\\tproc_name = name_symbol.get('name')\\n\\t\\n\\t#2. Now handle the extra information\\n\\tassert pairs.tag == 'OMATP'\\n\\tassert len(pairs) % 2 == 0\\n\\t\\n\\textras = {}\\n\\tcall_id = None\\n\\treturn_type = None\\n\\t\\n\\tfor i in range(0, len(pairs), 2):\\n\\t\\tsymbol = pairs[i]\\n\\t\\tassert symbol.tag == 'OMS'\\n\\t\\tassert symbol.get('cd') == \\\"scscp1\\\"\\n\\t\\tname = symbol.get('name')\\n\\t\\textras[name] = pairs[i+1]\\n\\t\\t\\n\\t\\tif name == 'call_id':\\n\\t\\t\\tassert call_id is None\\n\\t\\t\\tcall_id = pairs[i+1].text\\n\\t\\t\\tprint(call_id)\\n\\t\\telif name.startswith('option_return_'):\\n\\t\\t\\tassert return_type is None\\n\\t\\t\\treturn_type = ReturnTypes[name[14:]]\\n\\t\\n\\t#Some information is mandatory\\n\\tassert call_id is not None\\n\\tassert return_type is not None\\n\\t\\n\\treturn cd, proc_name, call_id, return_type, args[1:], extras\",\n \"def get_method_type(request_streaming, response_streaming):\\n if request_streaming and response_streaming:\\n return BIDI_STREAMING\\n elif request_streaming and not response_streaming:\\n return CLIENT_STREAMING\\n elif not request_streaming and response_streaming:\\n return SERVER_STREAMING\\n return UNARY\",\n \"def get_spi_response_type(cmd_num):\\n length = 8 # Default length of a response\\n resp_type = 1\\n if cmd_num in [8]:\\n # CMD8 gets R7\\n resp_type = 7\\n length = 40\\n if cmd_num in [5]:\\n # CMD5 gets a R4 back in SPI mode\\n resp_type = 4\\n length = 40\\n if cmd_num in [52,53]:\\n resp_type = 5\\n length = 16\\n \\n log.debug(\\\"Cmd %d expects response type R%s\\\" %(cmd_num,resp_type))\\n return (resp_type, length)\",\n \"def GetNativeInputInfo(is_optional):\\r\\n raise Exception(\\\"Abstract method\\\")\",\n \"def operation_type(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"operation_type\\\")\",\n \"def _on_response(self, response_type, p_api1, p_api2, double1, double2, ptr1, size1, ptr2, size2, ptr3, size3):\\n if self.debug:\\n print \\\"Response: \\\", ord(response_type)\\n if response_type == OnConnectionStatus.value:\\n self._on_connect_status(p_api2, chr(int(double1)), ptr1, size1)\\n elif self._callbacks:\\n for callback in self._callbacks:\\n if response_type == OnRtnDepthMarketData.value:\\n if self._is_market:\\n callback.on_market_rtn_depth_market_data_n(p_api2, ptr1)\\n elif response_type == OnRspQryInstrument.value:\\n obj = cast(ptr1, POINTER(InstrumentField)).contents\\n callback.on_trading_rsp_qry_instrument(p_api2, obj, bool(double1))\\n elif response_type == OnRspQryTradingAccount.value:\\n obj = cast(ptr1, POINTER(AccountField)).contents\\n callback.on_trading_rsp_qry_trading_account(p_api2, obj, bool(double1))\\n elif response_type == OnRspQryInvestorPosition.value:\\n obj = cast(ptr1, POINTER(PositionField)).contents\\n callback.on_trading_rsp_qry_investor_position(p_api2, obj, bool(double1))\\n elif response_type == OnRspQrySettlementInfo.value:\\n obj = cast(ptr1, POINTER(SettlementInfoField)).contents\\n callback.on_trading_rsp_qry_settlement_info(p_api2, obj, bool(double1))\\n elif response_type == OnRtnOrder.value:\\n obj = cast(ptr1, POINTER(OrderField)).contents\\n callback.on_trading_rtn_order(p_api2, obj)\\n elif response_type == OnRtnTrade.value:\\n obj = cast(ptr1, POINTER(TradeField)).contents\\n callback.on_trading_rtn_trade(p_api2, obj)\\n elif response_type == OnRtnQuote.value:\\n obj = cast(ptr1, POINTER(QuoteField)).contents\\n callback.on_trading_rtn_quote(p_api2, obj)\\n elif response_type == OnRtnQuoteRequest.value:\\n obj = cast(ptr1, POINTER(QuoteRequestField)).contents\\n callback.on_trading_rtn_quote_request(p_api2, obj)\\n elif response_type == OnRspQryHistoricalTicks.value:\\n obj = cast(ptr1, POINTER(TickField)).contents\\n obj2 = cast(ptr2, POINTER(HistoricalDataRequestField)).contents\\n callback.on_trading_rsp_qry_historical_ticks(p_api2, obj, obj2, bool(double1))\\n elif response_type == OnRspQryHistoricalBars.value:\\n obj = cast(ptr1, POINTER(BarField)).contents\\n obj2 = cast(ptr2, POINTER(HistoricalDataRequestField)).contents\\n callback.on_trading_rsp_qry_historical_bars(p_api2, obj, obj2, bool(double1))\\n elif response_type == OnRspQryInvestor.value:\\n obj = cast(ptr1, POINTER(InvestorField)).contents\\n callback.on_trading_rsp_qry_investor(p_api2, obj)\\n elif response_type == OnFilterSubscribe.value:\\n instrument = c_char_p(ptr1).value\\n callback.on_trading_filter_subscribe(p_api2, ExchangeType(double1), size1, size2, size3, instrument)\\n elif response_type == OnRtnError.value:\\n obj = cast(ptr1, POINTER(ErrorField)).contents\\n if self._is_market:\\n callback.on_market_rsp_error(p_api2, obj, bool(double1))\\n else:\\n callback.on_trading_rsp_error(p_api2, obj, bool(double1))\",\n \"def RequestInformation(self, request, inInfo, outInfo):\\n if self.need_to_read():\\n self._read_up_front()\\n self._update_time_steps()\\n return 1 # NOTE: ALWAYS return 1 on pipeline methods\",\n \"def _fc_out_parameters(self) -> Tuple[str, List[str]]:\\n out_pars = self.ret_type.fc_ret_type()\\n if len(out_pars) == 1:\\n return (out_pars[0][0], [])\\n\\n out_par_strl = list() # type: List[str]\\n for type_name, postfix in out_pars:\\n out_par_strl.append('{} {}'.format(\\n type_name, self.ret_type.name + postfix))\\n return ('void', out_par_strl)\",\n \"def __validate_input(self, request_data):\\n call_id = request_data.get(strings.CALL_ID_KEY)\\n request_timestamp = request_data.get(strings.TIMESTAMP_KEY)\\n request_start = request_data.get(strings.START_KEY)\\n validation = None\\n if call_id and request_timestamp and request_start is not None:\\n call_detail_query = CallDetail.objects.filter(call_id=call_id)\\n if call_detail_query:\\n if len(call_detail_query) < CALL_DETAILS_LIMIT:\\n stored_call_detail = call_detail_query[0]\\n if isinstance(request_start, str):\\n if request_start in strings.TRUE_VALUES:\\n request_start = True\\n else:\\n request_start = False\\n if stored_call_detail.start == request_start:\\n validation = {strings.INPUT_ERROR_KEY:\\n strings.START_END_ERROR}\\n stored_timestamp = standardize_date(\\n stored_call_detail.timestamp,\\n strings.COMPLETE_DATE_PATTERN)\\n request_timestamp = standardize_date(request_timestamp,\\n strings.\\n COMPLETE_DATE_PATTERN)\\n if stored_timestamp == request_timestamp:\\n validation = {strings.INPUT_ERROR_KEY:\\n strings.EQUAL_TIMESTAMPS_ERROR}\\n if stored_call_detail.start and not request_start:\\n if stored_timestamp > request_timestamp:\\n validation = {strings.INPUT_ERROR_KEY:\\n strings.SOONER_END_ERROR}\\n elif not stored_call_detail.start and request_start:\\n if stored_timestamp < request_timestamp:\\n validation = {strings.INPUT_ERROR_KEY:\\n strings.SOONER_END_ERROR}\\n else:\\n validation = {strings.INPUT_ERROR_KEY:\\n strings.CALL_LIMIT_ERROR}\\n\\n return validation\",\n \"def function_response_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EventSourceMappingFunctionResponseTypesItem']]]]:\\n return pulumi.get(self, \\\"function_response_types\\\")\",\n \"def construct_sp(self, info):\\n if \\\"query\\\" in info.keys():\\n if info[\\\"query\\\"].upper().startswith(\\\"CALL\\\"):\\n self.q_str = info[\\\"query\\\"]\\n self.sql_type_ind = (info[\\\"q_type_ind\\\"] if \\\"q_type_ind\\\" in info.keys() else\\n sql_type.STORED_PROCEDURE_NO_RES)\\n\\n self.return_result = bool((self.sql_type_ind is sql_type.SELECT or\\\\\\n self.sql_type_ind is sql_type.STORED_PROCEDURE_RES))\\n\\n elif \\\"procedure\\\" in info.keys():\\n self.q_str = info[\\\"procedure\\\"]\\n\\n self.sql_type_ind = (info[\\\"q_type_ind\\\"] if \\\"q_type_ind\\\" in info.keys() else\\n sql_type.STORED_PROCEDURE_NO_RES)\\n\\n self.return_result = bool((self.sql_type_ind is sql_type.SELECT or\\\\\\n self.sql_type_ind is sql_type.STORED_PROCEDURE_RES))\",\n \"def build_method_call(code, line, method_object):\\n full_signature = method_object[\\\"methodSignature\\\"]\\n normalised_signature = normalise_signature(full_signature)\\n param_values = get_method_parameter_values(code, line, full_signature)\\n string_values, cmplx_types = get_string_values(param_values, full_signature)\\n\\n rpc_payload_length = str(\\n 4 + len(normalised_signature) + len(string_values)\\n )\\n # Default to stub value if method-to-service correlation failed\\n strong_name = (\\n method_object[\\\"service\\\"][\\\"strongName\\\"]\\n if method_object[\\\"service\\\"] is not None\\n else \\\"X\\\"*32\\n )\\n rpc_blocks = []\\n rpc_blocks.extend([\\n RPC_VERSION,\\n RPC_FLAGS,\\n rpc_payload_length,\\n BASE_URL,\\n strong_name,\\n method_object[\\\"rmtSvcIntName\\\"],\\n method_object[\\\"methodName\\\"],\\n ])\\n rpc_blocks.extend(normalised_signature)\\n rpc_blocks.extend(string_values)\\n rpc_blocks.extend([\\n \\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\",\\n method_object[\\\"paramCount\\\"]\\n ])\\n rpc_blocks.extend(\\n generate_parameter_map(\\n rpc_blocks,\\n full_signature,\\n param_values\\n )\\n )\\n return rpc_blocks, cmplx_types\",\n \"def checkRequestType(packet):\\n info = [packet[i : i + 2] for i in range(0, len(packet), 2)]\\n RequestType = int.from_bytes(info[2], \\\"big\\\")\\n if RequestType == 0x0001:\\n return \\\"date\\\"\\n elif RequestType == 0x0002:\\n return \\\"time\\\"\\n else:\\n return -1\",\n \"def get_operation(operation):\\n if operation == 'query':\\n return banking_pb2.QUERY\\n if operation == 'deposit':\\n return banking_pb2.DEPOSIT\\n if operation == 'withdraw':\\n return banking_pb2.WITHDRAW\",\n \"def _handle_one_message(self):\\n\\n type, data = self.cxn.recv_message()\\n\\n if type.startswith(\\\"call\\\"):\\n if len(data) != 3:\\n message = (type, data)\\n raise MessageError.invalid(message, \\\"incorrect number of args\\\")\\n flags = {\\n \\\"want_response\\\": type == \\\"call\\\",\\n }\\n call = Call(data[0], data[1], data[2], flags, self.client)\\n self._handle_call(call)\\n return False\\n\\n raise MessageError.bad_type(type)\",\n \"def analyze_input():\\n\\n # Generate action_id classes for OF 1.3\\n for wire_version, ordered_classes in of_g.ordered_classes.items():\\n if not wire_version in [of_g.VERSION_1_3]:\\n continue\\n classes = versions[of_g.of_version_wire2name[wire_version]]['classes']\\n for cls in ordered_classes:\\n if not loxi_utils.class_is_action(cls):\\n continue\\n action = cls[10:]\\n if action == '' or action == 'header':\\n continue\\n name = \\\"of_action_id_\\\" + action\\n members = classes[\\\"of_action\\\"][:]\\n of_g.ordered_classes[wire_version].append(name)\\n if type_maps.action_id_is_extension(name, wire_version):\\n # Copy the base action classes thru subtype\\n members = classes[\\\"of_action_\\\" + action][:4]\\n classes[name] = members\\n\\n # @fixme If we support extended actions in OF 1.3, need to add IDs\\n # for them here\\n\\n for wire_version in of_g.wire_ver_map.keys():\\n version_name = of_g.of_version_wire2name[wire_version]\\n calculate_offsets_and_lengths(\\n of_g.ordered_classes[wire_version],\\n versions[version_name]['classes'],\\n wire_version)\",\n \"def get_response_type(cmd_num):\\n length = 48 # Default length of a response\\n if cmd_num in [0,4,15]:\\n # No response expected\\n rv = None\\n if cmd_num in [11,13,16,17,18,19,23,55,56]:\\n # Response type 1\\n rv = 1\\n if cmd_num in [7,12,20]:\\n # Response type 1b, means it could also be a busy\\n rv = 1.5\\n if cmd_num in [2,9,10]:\\n # Reponse type 2, CID/CSD register, not on SDIO but here for completeness\\n length = 136\\n rv = 2\\n if cmd_num in [4,5]:\\n rv = 4\\n if cmd_num in [52,53]:\\n rv = 5\\n if cmd_num in [3]:\\n rv = 6\\n if cmd_num in [8]:\\n rv = 7\\n log.debug(\\\"Cmd %d expects response type R%s\\\" %(cmd_num,rv))\\n return (rv, length)\",\n \"def _fi_out_parameters(self) -> Tuple[str, List[Tuple[str, str]]]:\\n out_pars = self.ret_type.fi_ret_type()\\n if len(out_pars) == 1:\\n return (out_pars[0][0], [])\\n\\n out_par_list = list() # type: List[Tuple[str, str]]\\n for par_type, par_name in out_pars:\\n out_par_list.append((par_type, 'ret_val' + par_name))\\n\\n return ('', out_par_list)\",\n \"def processRequest(cls, ps, **kw):\\n resource = kw['resource']\\n method = resource.getOperation(ps, None) # This getOperation method is valid for ServiceSOAPBinding subclass\\n rsp = method(ps, **kw)[1] # return (request, response) but we only need response\\n return rsp\",\n \"def validate_args(self, in_args, cmd_call):\\n valid_1, valid_2 = None, None\\n\\n if len(in_args) > 0 and type(in_args) is not list:\\n args = in_args.split()\\n valid_1 = args[0]\\n elif type(in_args) is list and len(in_args) > 0:\\n args = in_args\\n valid_1 = args[0]\\n else:\\n args = []\\n\\n if cmd_call in ['default']:\\n # Default : Returns a valid cui type for an input cui\\n # checks to see if there is more than 2 arguments\\n # if so, arg[0] may be a valid code\\n # arg[1] may be a valid code type\\n # if not ask the user what type of code type arg[0] is\\n # valid_1 = valid cui type\\n # valid_2 = None\\n while True:\\n if len(args) >= 2 and len(args) <= 3:\\n input_type = args[1].upper()\\n else:\\n input_type = input(\\\"What type of id is '{0}'? [LOCAL/RXCUI/NDC/SNOMED]\\\".format(args[0])).upper()\\n\\n # Confirm it's a valid code type\\n valid_type = self.validate_id_type(input_type)\\n # Valid type is a boolean of True\\n if isinstance(valid_type, str) or valid_type is None:\\n return None\\n elif valid_type:\\n break\\n elif not valid_type:\\n print('Invalid Option, Please Try Again')\\n continue\\n valid_1 = input_type\\n\\n elif cmd_call in self.cmd_config_default:\\n # valid_1 : Valid Cui , valid_2 : Valid Cui Type\\n valid_2, _ = self.validate_args(args, 'default')\\n valid_1 = args[0]\\n\\n elif cmd_call == 'code_lookup':\\n # args[0] : Initial CUI, args[1] : Initial CUI Type, args[2] : Target CUI Type\\n # valid_1 : valid cui, valid_2 : list valid source and target\\n _dict_opts = util.OPTIONS_CUI_TYPES.copy()\\n _avail = list(set(smores.get_dict_sources()) & set(_dict_opts))\\n if len(_avail) == 0 and len(args) < 2:\\n print('There are no available starting cui types that can be crosswalked.\\\\n'\\n 'Please load a file containing valid cui types: {0}'.format(_dict_opts))\\n return False, None\\n\\n if len(args) >= 2:\\n if len(args) == 3:\\n # provided cui, cui source, and target\\n valid_2, _ = self.validate_args(args, 'default')\\n source, target = args[1].upper(), args[2].upper()\\n else:\\n source, target = args[0].upper(), args[1].upper()\\n valid_1 = simple_input(\\\"Is {0} the correct starting source? \\\".format(source), ['YES', 'NO', 'exit'])\\n if valid_1 == 'exit':\\n return False, None\\n # TODO need path for valid_2\\n else:\\n valid_1 = simple_input(\\\"Which code set do you want to start with?\\\", _avail)\\n if valid_1 != 'exit':\\n _dict_opts.remove(valid_1) # Don't lookup what we've already got\\n valid_2 = simple_input(\\\"Which code set do you want to get results for?\\\", _dict_opts)\\n if valid_2 == 'exit':\\n return False, None\\n else:\\n return False, None\\n\\n elif cmd_call == 'errors':\\n _current_err = list(self.errors.keys())\\n if len(args) > 1:\\n smores_error('#Cx001.7', console_p=True)\\n return\\n elif len(args) == 1 and args[0].lower() in _current_err:\\n valid_1 = args[0]\\n elif len(args) == 1:\\n print('There are currently no errors logged for that command.')\\n return\\n else:\\n valid_1 = simple_input(\\\"Please choose a command from the list to see errors: \\\", _current_err)\\n\\n elif cmd_call in ['csv', 'remap', 'fhir', 'json']:\\n # Format: [File] [Output]\\n if not self.inputs['loaded']:\\n print(\\\"No Files Loaded!\\\\nYou Must load a file containing local medications first\\\")\\n else:\\n _file_opts = list(self.inputs['files'].keys()) + ['All']\\n _dict_opts = list(smores.get_dict_sources(True)) #+ ['All']\\n _file_or_dict = None\\n\\n if cmd_call in ['csv', 'json']:\\n if len(args) == 0:\\n _file_or_dict = simple_input(\\\"Do you want results for a File or a constructed Dictionary?\\\",\\n ['File', 'Dictionary', 'exit'], True)\\n elif args[0] not in _file_opts and args[0] not in _dict_opts:\\n print('That option was not recognized as a valid source.')\\n _file_or_dict = simple_input(\\\"Do you want results for a File or a constructed Dictionary?\\\",\\n ['File', 'Dictionary', 'exit'], True)\\n else:\\n valid_1 = args[0]\\n\\n if _file_or_dict.upper() == 'FILE':\\n valid_1 = 'FILE|' + simple_input(\\\"Please choose a loaded file\\\", _file_opts, True)\\n\\n elif _file_or_dict.upper() == 'DICTIONARY':\\n valid_1 = 'DICT|' + simple_input(\\\"Please choose a code dictionary to output\\\", _dict_opts, True)\\n elif _file_or_dict.upper() == 'EXIT':\\n return None, None\\n\\n else:\\n valid_1 = simple_input(\\\"Please choose a loaded file\\\", _file_opts, True)\\n\\n if cmd_call in ['csv', 'json', 'fhir']:\\n if len(args) == 2 and len(args[1]) > 0:\\n valid_2 = args[1]\\n else:\\n valid_2= input(\\\"Please provide an output file name:\\\").strip()\\n\\n if len(valid_2) > 0:\\n if \\\".\\\" in valid_2:\\n valid_2, ext = valid_2.split(\\\".\\\")\\n else:\\n valid_2 = ''\\n print('Empty file name provided, using default.')\\n else:\\n valid_2 = args[0]\\n\\n elif cmd_call == 'file':\\n re_use = False\\n if self.inputs['loaded'] and len(in_args) == 0:\\n print(\\\"The following file(s) have already been loaded: \\\\n\\\" + str(self.inputs['files']))\\n _load_more = simple_input(\\\"Would you like to load an additional file?\\\", ['Y', 'N', 'exit'])\\n if _load_more == 'Y':\\n pass\\n elif _load_more == 'N':\\n _re_use = simple_input(\\\"Would you like to re-use a loaded file?\\\", ['Y', 'N', 'exit'])\\n if _re_use == 'Y':\\n re_use = True\\n else:\\n return False, None\\n else:\\n return False, None\\n\\n if in_args is not None and len(in_args) > 0:\\n valid_1 = in_args\\n else:\\n valid_1 = input(\\\"Please enter the name of the file to load: \\\") if not re_use else simple_input(\\n 'Select the file to be used: ', list(self.inputs['files'].keys()), index=True)\\n\\n while True:\\n if valid_1 in self.inputs['files']:\\n if not re_use:\\n print(\\\"It looks like you've already loaded that file. Please try a different file.\\\")\\n valid_1, valid_2 = input(\\\"Please enter the name of the file to load: \\\")\\n else:\\n break\\n elif len(valid_1) == 0:\\n smores_error('#Cx001.7', logger=smoresLog)\\n valid_1, valid_2 = input(\\\"Please enter the name of the file to load: \\\")\\n else:\\n break\\n\\n if not resolve_target_path(valid_1):\\n valid_1, valid_2 = self.validate_args('', 'file')\\n\\n elif '.smr' in valid_1:\\n if len(self.inputs['files']) > 0:\\n print(\\n 'It looks like you are trying to load a session, this will replace the current session and '\\n 'all previous work.')\\n _save = simple_input('Do you want to save the current session first?', ['Y', 'N', 'EXIT'])\\n if _save == 'Y':\\n smores.save_session(self.__version__)\\n elif _save == 'EXIT':\\n return False, None\\n valid_2 = 'session'\\n else:\\n valid_2 = 'file'\\n\\n smoresLog.debug('Args: {0}, Validated as: {1}'.format(valid_1, valid_2))\\n return valid_1, valid_2\",\n \"def GetNativeOutputInfo(\\r\\n is_struct=False,\\r\\n featurizer_name=\\\"\\\",\\r\\n ):\\r\\n raise Exception(\\\"Abstract method\\\")\",\n \"def _get_request_parser(self, operation):\\n\\n wpsrequest = self\\n\\n def parse_get_getcapabilities(http_request):\\n \\\"\\\"\\\"Parse GET GetCapabilities request\\n \\\"\\\"\\\"\\n\\n acceptedversions = _get_get_param(http_request, 'acceptversions')\\n wpsrequest.check_accepted_versions(acceptedversions)\\n\\n def parse_get_describeprocess(http_request):\\n \\\"\\\"\\\"Parse GET DescribeProcess request\\n \\\"\\\"\\\"\\n version = _get_get_param(http_request, 'version')\\n wpsrequest.check_and_set_version(version)\\n\\n language = _get_get_param(http_request, 'language')\\n wpsrequest.check_and_set_language(language)\\n\\n wpsrequest.identifiers = _get_get_param(\\n http_request, 'identifier', aslist=True)\\n\\n def parse_get_execute(http_request):\\n \\\"\\\"\\\"Parse GET Execute request\\n \\\"\\\"\\\"\\n version = _get_get_param(http_request, 'version')\\n wpsrequest.check_and_set_version(version)\\n\\n language = _get_get_param(http_request, 'language')\\n wpsrequest.check_and_set_language(language)\\n\\n wpsrequest.identifier = _get_get_param(http_request, 'identifier')\\n wpsrequest.store_execute = _get_get_param(\\n http_request, 'storeExecuteResponse', 'false')\\n wpsrequest.status = _get_get_param(http_request, 'status', 'false')\\n wpsrequest.lineage = _get_get_param(\\n http_request, 'lineage', 'false')\\n wpsrequest.inputs = get_data_from_kvp(\\n _get_get_param(http_request, 'DataInputs'), 'DataInputs')\\n wpsrequest.outputs = {}\\n\\n # take responseDocument preferably\\n resp_outputs = get_data_from_kvp(\\n _get_get_param(http_request, 'ResponseDocument'))\\n raw_outputs = get_data_from_kvp(\\n _get_get_param(http_request, 'RawDataOutput'))\\n wpsrequest.raw = False\\n if resp_outputs:\\n wpsrequest.outputs = resp_outputs\\n elif raw_outputs:\\n wpsrequest.outputs = raw_outputs\\n wpsrequest.raw = True\\n # executeResponse XML will not be stored and no updating of\\n # status\\n wpsrequest.store_execute = 'false'\\n wpsrequest.status = 'false'\\n\\n if not operation:\\n raise MissingParameterValue('Missing request value', 'request')\\n else:\\n self.operation = operation.lower()\\n\\n if self.operation == 'getcapabilities':\\n return parse_get_getcapabilities\\n elif self.operation == 'describeprocess':\\n return parse_get_describeprocess\\n elif self.operation == 'execute':\\n return parse_get_execute\\n else:\\n raise OperationNotSupported(\\n 'Unknown request %r' % self.operation, operation)\",\n \"def _process_operation(operation_pb):\\n match = _OPERATION_NAME_RE.match(operation_pb.name)\\n if match is None:\\n raise ValueError('Operation name was not in the expected '\\n 'format after instance creation.',\\n operation_pb.name)\\n location_id = match.group('location_id')\\n operation_id = int(match.group('operation_id'))\\n\\n request_metadata = _parse_pb_any_to_native(operation_pb.metadata)\\n operation_begin = _pb_timestamp_to_datetime(\\n request_metadata.request_time)\\n\\n return operation_id, location_id, operation_begin\",\n \"def test_decoding_method(self):\\n data = service_call.encode_call(\\\"foo\\\", [42])\\n name, params = service_call.decode_call(data)\\n\\n self.assertEqual(name, \\\"foo\\\")\\n self.assertEqual(params, [42])\",\n \"def GetInput(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def _extract_commands(self, data):\\n version = data[6]\\n if version > 1:\\n raise CarError('only version 1 is supported')\\n if data[8] == 1:\\n if self.inputastext is None:\\n self.inputastext = True\\n if data[9] == 1:\\n if self.outputastext is None:\\n self.outputastext = True\\n data = data[10:]\\n data = struct.unpack('<' + 'I' * (len(data) // 4), data)\\n commands = tuple((data[i], data[i + 1]) for i in range(3, len(data), 2))\\n for x, a in filter(lambda x: x[0] in (GOTO, IF), commands):\\n if a >= len(commands):\\n raise CarError('code position out of scope')\\n return commands, data[:3]\",\n \"def traffic_statuscodes_requestresponsetype(self, **kwargs):\\n url_path = 'traffic/statuscodes/requestresponsetype'\\n self.logger.debug(f\\\"Get list of request-response types\\\")\\n body = self._make_body(kwargs)\\n return self._common_get(request_path=url_path, parameters=body)\",\n \"def function_response_types(self) -> pulumi.Output[Optional[Sequence['EventSourceMappingFunctionResponseTypesItem']]]:\\n return pulumi.get(self, \\\"function_response_types\\\")\",\n \"def pre_get_operation(\\n self,\\n request: operations_pb2.GetOperationRequest,\\n metadata: Sequence[Tuple[str, str]],\\n ) -> Tuple[operations_pb2.GetOperationRequest, Sequence[Tuple[str, str]]]:\\n return request, metadata\",\n \"def pre_get_operation(\\n self,\\n request: operations_pb2.GetOperationRequest,\\n metadata: Sequence[Tuple[str, str]],\\n ) -> Tuple[operations_pb2.GetOperationRequest, Sequence[Tuple[str, str]]]:\\n return request, metadata\",\n \"def action_GetProtocolInfo(self, extract_returns=True):\\n arguments = { }\\n\\n out_params = self._proxy_call_action(\\\"GetProtocolInfo\\\", arguments=arguments)\\n\\n rtn_args = out_params\\n if extract_returns:\\n rtn_args = [out_params[k] for k in (\\\"Source\\\", \\\"Sink\\\",)]\\n if len(rtn_args) == 1:\\n rtn_args = rtn_args[0]\\n\\n return rtn_args\",\n \"def _find_collection_response(op: Operation) -> Tuple[int, Any]:\\n for code, resp_model in op.response_models.items():\\n if resp_model is None or resp_model is NOT_SET:\\n continue\\n\\n model = resp_model.__annotations__[\\\"response\\\"]\\n if is_collection_type(model):\\n item_schema = get_collection_args(model)[0]\\n return code, item_schema\\n\\n raise ConfigError(\\n f'\\\"{op.view_func}\\\" has no collection response (e.g. response=List[SomeSchema])'\\n )\",\n \"def gen_proto_recv(signame, argname, typename, size, is_enum, is_struct, is_varlen):\\n add_code = None\\n wordoff = word_offset(signame, argname)\\n if is_varlen:\\n # Array. Logic is identical to send direction; copying\\n # is done elsewhere, we just return an offset.\\n # The offset's the same for send, so we don't need\\n # to generate any code.\\n proto_code = None\\n copy_code = None\\n signature = None\\n else:\\n signature = mangle_type(typename)\\n if is_struct:\\n proto_code = \\\"%s *%s\\\" % (typename, argname)\\n copy_code = \\\" CCP_%s_%s_GET(pdu, %s);\\\" % (\\n signame.upper(), argname.upper(), argname)\\n else:\\n proto_code = \\\"%s *%s\\\" % (typename, argname)\\n cast = \\\"(%s)\\\" % (typename)\\n copy_code = \\\" *%s = %sCCP_%s_%s_GET(pdu);\\\" % (\\n argname, cast, signame.upper(), argname.upper())\\n return (proto_code, copy_code, add_code, signature)\",\n \"def gen_CRM(call_text, response_text):\\n pass\",\n \"def _format_call(value: ast3.Call, context: types.Context) -> typing.Text:\\n\\ttry:\\n\\t\\treturn _format_call_horizontal(value, context)\\n\\texcept errors.NotPossible:\\n\\t\\treturn _format_call_vertical(value, context)\",\n \"def GetOutputType(self, response_type):\\n if response_type == \\\"KML\\\":\\n return \\\"xml\\\"\\n return \\\"json\\\"\",\n \"def _process_request(self, request):\\n try:\\n self._validate_rpc_request(request)\\n except ValueError as err:\\n return self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err, keep_null_id=True)\\n\\n id = request.get('id', None)\\n\\n try:\\n method = getattr(rpc, request['method'])\\n except AttributeError as err:\\n return self._build_rpc_error(id, RpcErrors.METHOD_NOT_FOUND, err)\\n\\n try:\\n params = request.get('params', None)\\n if params is None:\\n result = method()\\n elif isinstance(params, list):\\n result = method(*params)\\n elif isinstance(params, dict):\\n result = method(**params)\\n\\n return self._build_rpc_result(id, result)\\n\\n except TypeError as err:\\n return self._build_rpc_error(id, RpcErrors.INVALID_PARAMS, err)\\n except Exception as err:\\n return self._build_rpc_error(id, RpcErrors.INTERNAL_ERROR, err)\",\n \"def check_message_params(message : dict) -> (bool, dict):\\n logging.info('CHECKING message: '+str(message))\\n\\n data_tag = 'data'\\n chat_data_tag = 'chat-data'\\n param_tag = 'sessionJson'\\n\\n if data_tag in message:\\n #Send the 'data' from the input to be checked\\n extracted_params = parse_chat_input(message[data_tag]) #returns {choice, chat-data or None}\\n logging.info('INPUT PARAMS:'+str(extracted_params))\\n\\n if extracted_params is None:\\n logging.info('Missing (input param data) from protocol message')\\n else:\\n if 'choice' not in extracted_params or chat_data_tag not in extracted_params:\\n logging.info('Missing (choice AND/OR data) in protocol message')\\n else:\\n choice = extracted_params.pop('choice')\\n if choice == 1:\\n return (choice, check_login_message(extracted_params))\\n if choice == 2:\\n #Add the session data back onto the result\\n extracted_params.update(message[param_tag])\\n return (choice, check_chat_message(extracted_params))\\n if choice == 3:\\n return (choice, (True, None))\\n return (-1, (None, None))\",\n \"def process_all_call_arg(self, code, option):\\n return code\",\n \"def from_output(cls, output: bytes, method: Method):\\n s = None\\n if b\\\"=====ERROR=====\\\" in output:\\n s = cls.ERROR\\n elif b\\\"=====UNKNOWN=====\\\" in output:\\n s = cls.UNKNOWN\\n elif b\\\"=====UNSATISFIABLE=====\\\" in output:\\n s = cls.UNSATISFIABLE\\n elif (\\n b\\\"=====UNSATorUNBOUNDED=====\\\" in output or b\\\"=====UNBOUNDED=====\\\" in output\\n ):\\n s = cls.UNBOUNDED\\n elif method is Method.SATISFY:\\n if b\\\"==========\\\" in output:\\n s = cls.ALL_SOLUTIONS\\n elif b\\\"----------\\\" in output:\\n s = cls.SATISFIED\\n else:\\n if b\\\"==========\\\" in output:\\n s = cls.OPTIMAL_SOLUTION\\n elif b\\\"----------\\\" in output:\\n s = cls.SATISFIED\\n return s\",\n \"def process_check_protocol_callback(data):\\n signature = data.get('signature')\\n if not signature:\\n return {'error': 'missing signature'}\\n try:\\n task = AnalysisTask.objects.get(id=signature)\\n except AnalysisTask.DoesNotExist:\\n return {'error': 'invalid signature'}\\n\\n entity = task.entity\\n version = task.version\\n task.delete() # So it can be re-run later if desired, and keep the table small\\n\\n if 'returntype' not in data:\\n return {'error': 'missing returntype'}\\n success = data['returntype'] == 'success'\\n\\n if success:\\n # Store protocol interface in the repocache\\n if 'required' not in data or 'optional' not in data or 'ioputs' not in data:\\n return {'error': 'missing terms'}\\n cached_version = entity.repocache.get_version(version)\\n cached_version.parsed_ok = True\\n cached_version.interface.all().delete() # Remove results of any previous analysis\\n cached_version.save()\\n terms = [\\n ProtocolInterface(protocol_version=cached_version, term=term, optional=False)\\n for term in data['required']\\n ] + [\\n ProtocolInterface(protocol_version=cached_version, term=term, optional=True)\\n for term in data['optional']\\n ]\\n try:\\n ProtocolInterface.objects.bulk_create(terms)\\n except IntegrityError as e:\\n return {'error': 'duplicate term provided: ' + str(e)}\\n kinds = {name: value for value, name in ProtocolIoputs.KIND_CHOICES}\\n ioputs = [\\n ProtocolIoputs(\\n protocol_version=cached_version,\\n name=ioput['name'],\\n units=ioput['units'],\\n kind=kinds[ioput['kind']])\\n for ioput in data['ioputs']\\n ]\\n # Store a flag so we know the interface has been analysed\\n ioputs.append(ProtocolIoputs(protocol_version=cached_version, name=' ', kind=ProtocolIoputs.FLAG))\\n try:\\n ProtocolIoputs.objects.bulk_create(ioputs)\\n except IntegrityError as e:\\n return {'error': 'duplicate input or output provided: ' + str(e)}\\n else:\\n # Store error message as an ephemeral file\\n error_message = data.get('returnmsg', '').replace('
', '\\\\n')\\n if not error_message:\\n return {'error': 'no error message supplied'}\\n commit = entity.repo.get_commit(version)\\n\\n if ERROR_FILE_NAME in commit.filenames:\\n logger.warning('Error file already exists in commit. New error message is: %s', error_message)\\n else:\\n content = b'Error analysing protocol:\\\\n\\\\n' + error_message.encode('UTF-8')\\n commit.add_ephemeral_file(ERROR_FILE_NAME, content)\\n # Don't try to analyse this protocol again\\n cached_version = entity.repocache.get_version(version)\\n cached_version.parsed_ok = False\\n cached_version.save()\\n ProtocolIoputs(protocol_version=cached_version, name=' ', kind=ProtocolIoputs.FLAG).save()\\n\\n return {}\",\n \"def test_get_request_output(self):\\n pass\",\n \"def _process_convert_output_(self, output_data, **kwargs):\\n accept_input, current_state, output = output_data\\n if kwargs['full_output']:\\n if current_state.label() is None:\\n return (accept_input, current_state, None)\\n else:\\n return (accept_input, current_state, output)\\n else:\\n if not accept_input:\\n return None\\n return output\",\n \"def _process_convert_output_(self, output_data, **kwargs):\\n accept_input, current_state, output = output_data\\n return (accept_input, current_state, output)\",\n \"def post_call(self, date='2014-02-12', time='22:20:33', rnumber='0674767730', rname='Romain', snumber='0617382221', sname='Lolo'):\\n xmldata1 = \\\"\\\" + \\\\\\n \\\"\\\" + \\\\\\n \\\"\\\" + \\\\\\n \\\"\\\" + \\\\\\n \\\"text/xml \\\" + \\\\\\n \\\"call \\\" + \\\\\\n \\\"\\\" + \\\\\\n \\\"<Category>Incoming Call</Category>\\\" + \\\\\\n \\\"<DisplayType>Maximum</DisplayType>\\\" + \\\\\\n \\\"<CallTime>\\\" + \\\\\\n \\\"<Date>\\\"\\n xmldata2 = \\\"</Date>\\\" + \\\\\\n \\\"<Time>\\\"\\n xmldata3 = \\\"</Time>\\\" + \\\\\\n \\\"</CallTime>\\\" + \\\\\\n \\\"<Callee>\\\" + \\\\\\n \\\"<Number>\\\"\\n xmldata4 = \\\"</Number>\\\" + \\\\\\n \\\"<Name>\\\"\\n xmldata5 = \\\"</Name>\\\" + \\\\\\n \\\"</Callee>\\\" + \\\\\\n \\\"<Caller>\\\" + \\\\\\n \\\"<Number>\\\"\\n xmldata6 = \\\"</Number>\\\" + \\\\\\n \\\"<Name>\\\"\\n xmldata7 = \\\"</Name>\\\" + \\\\\\n \\\"</Caller>\\\" + \\\\\\n \\\" \\\" + \\\\\\n \\\" \\\" + \\\\\\n \\\" \\\" + \\\\\\n \\\" \\\"\\n\\n #Create Header for Message\\n header = \\\"POST /PMR/control/MessageBoxService HTTP/1.0\\\\r\\\\n\\\" + \\\\\\n \\\"Content-Type: text/xml; charset=\\\\\\\"utf-8\\\\\\\"\\\\r\\\\n\\\" + \\\\\\n \\\"Host: \\\" + self.host + \\\"\\\\r\\\\n\\\" + \\\\\\n \\\"Content-Length: \\\" + str(len(xmldata1) + len(date) + \\\\\\n len(xmldata2) + len(time) + \\\\\\n len(xmldata3) + len(rnumber) + \\\\\\n len(xmldata4) + len(rname) + \\\\\\n len(xmldata5) + len(snumber) + \\\\\\n len(xmldata6) + len(sname) + \\\\\\n len(xmldata7)) + \\\"\\\\r\\\\n\\\" + \\\\\\n \\\"SOAPACTION: urn:samsung.com:service:MessageBoxService:1#AddMessage\\\\r\\\\n\\\" + \\\\\\n \\\"Connection: close\\\\r\\\\n\\\\r\\\\n\\\"\\n #Create socket\\n full_soap_request = header + \\\\\\n xmldata1 + date + \\\\\\n xmldata2 + time + \\\\\\n xmldata3 + rnumber + \\\\\\n xmldata4 + rname + \\\\\\n xmldata5 + snumber +\\\\\\n xmldata6 + sname +\\\\\\n xmldata7\\n msg_port = 52235;\\n\\n try:\\n # Open Socket\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n sock.connect((self.host, msg_port))\\n sock.send(full_soap_request.encode('utf-8'))\\n read = sock.recv(1024)\\n # print(\\\"\\\\n\\\\n Reader \\\\n\\\\n\\\" + read)\\n sock.close()\\n except socket.error, e:\\n raise TVError(e[1], 'post_call')\\n finally:\\n sock.close()\\n sock = None\",\n \"def get_net_context(self, net):\\n inputs = []\\n outputs = []\\n in_cons = []\\n out_cons = []\\n\\n for con in self.connections:\\n if net == self.connections[con].input:\\n outputs += [self.connections[con].output]\\n in_cons += [con]\\n if net == self.connections[con].output:\\n inputs += [self.connections[con].input]\\n out_cons += [con]\\n\\n return inputs, in_cons, out_cons, outputs\",\n \"def get_info_on_inputs(named_inputs, n_unnamed_inputs):\\r\\n n_named_inputs = len(named_inputs)\\r\\n\\r\\n def get_plural(n):\\r\\n if n > 1:\\r\\n return 's'\\r\\n else:\\r\\n return ''\\r\\n\\r\\n if n_named_inputs == 0:\\r\\n if n_unnamed_inputs == 0:\\r\\n msg = 'The function is supposed to have no input.'\\r\\n else:\\r\\n if n_unnamed_inputs == 1:\\r\\n msg = (\\\"The function has a single input variable which has no \\\"\\r\\n \\\"name, and thus cannot be assigned through a keyword\\\"\\r\\n \\\" argument (use 'name=...' in a Variable's \\\"\\r\\n \\\"constructor to give it a name).\\\")\\r\\n else:\\r\\n # Use plural.\\r\\n msg = (\\\"The function has %s inputs, but none of them is named,\\\"\\r\\n \\\" and thus they cannot be assigned through keyword \\\"\\r\\n \\\"arguments (use 'name=...' in a Variable's \\\"\\r\\n \\\"constructor to give it a name).\\\" % n_unnamed_inputs)\\r\\n else:\\r\\n if n_unnamed_inputs == 0:\\r\\n msg = (\\\"The function has %s named input%s (%s).\\\" % (\\r\\n n_named_inputs, get_plural(n_named_inputs),\\r\\n ', '.join(named_inputs)))\\r\\n else:\\r\\n msg = (\\\"The function has %s named input%s (%s), and %s unnamed \\\"\\r\\n \\\"input%s which thus cannot be accessed through keyword \\\"\\r\\n \\\"argument%s (use 'name=...' in a variable's constructor \\\"\\r\\n \\\"to give it a name).\\\" % (\\r\\n n_named_inputs, get_plural(n_named_inputs),\\r\\n ', '.join(named_inputs), n_unnamed_inputs,\\r\\n get_plural(n_unnamed_inputs),\\r\\n get_plural(n_unnamed_inputs)))\\r\\n return msg\",\n \"def response_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"response_types\\\")\",\n \"def response_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"response_types\\\")\",\n \"def _parse_output_request(self, req):\\n\\n output_request = self._output_request_type_check(req)\\n\\n for request in output_request:\\n if request not in self.OUT_ATTRS:\\n msg = ('User output request \\\"{}\\\" not recognized. '\\n 'Will attempt to extract from PySAM.'.format(request))\\n logger.debug(msg)\\n\\n modules = []\\n for request in output_request:\\n if request in self.OPTIONS:\\n modules.append(self.OPTIONS[request])\\n\\n if not any(modules):\\n msg = ('None of the user output requests were recognized. '\\n 'Cannot run reV econ. '\\n 'At least one of the following must be requested: {}'\\n .format(list(self.OPTIONS.keys())))\\n logger.exception(msg)\\n raise ExecutionError(msg)\\n\\n b1 = [m == modules[0] for m in modules]\\n b2 = np.array([m == WindBos for m in modules])\\n b3 = np.array([m == SingleOwner for m in modules])\\n\\n if all(b1):\\n self._sam_module = modules[0]\\n self._fun = modules[0].reV_run\\n elif all(b2 | b3):\\n self._sam_module = SingleOwner\\n self._fun = SingleOwner.reV_run\\n else:\\n msg = ('Econ outputs requested from different SAM modules not '\\n 'currently supported. Output request variables require '\\n 'SAM methods: {}'.format(modules))\\n raise ValueError(msg)\\n\\n return list(set(output_request))\",\n \"def _call(self, name, *args, **kwargs):\\r\\n if len(args) and len(kwargs):\\r\\n raise TypeError(\\r\\n 'Use positional or keyword argument only.'\\r\\n )\\r\\n\\r\\n callinfo = getattr(self, name).callinfo\\r\\n soapAction = callinfo.soapAction\\r\\n url = callinfo.location\\r\\n (protocol, host, uri, query, fragment, identifier) = urlparse(url)\\r\\n port = '80'\\r\\n if host.find(':') >= 0:\\r\\n host, port = host.split(':')\\r\\n\\r\\n binding = Binding(host=host, tracefile=self._tracefile,\\r\\n ssl=(protocol == 'https'),\\r\\n port=port, url=None, typesmodule=self._typesmodule,\\r\\n nsdict=self._nsdict, soapaction=self._soapAction,\\r\\n ns=self._ns, op_ns=self._op_ns)\\r\\n\\r\\n if self._use_wsdl:\\r\\n request, response = self._getTypeCodes(callinfo)\\r\\n if len(kwargs): args = kwargs\\r\\n if request is None:\\r\\n request = Any(oname=name)\\r\\n binding.Send(url=uri, opname=None, obj=args,\\r\\n nsdict=self._nsdict, soapaction=soapAction, requesttypecode=request)\\r\\n return binding.Receive(replytype=response)\\r\\n\\r\\n apply(getattr(binding, callinfo.methodName), args)\\r\\n\\r\\n return binding.Receive()\",\n \"def rpc_info():\",\n \"def validate_input(request):\\n\\n # Validate errors inputs\\n request_data = JSONParser().parse(request)\\n\\n if 'action' not in request_data:\\n return_data = {'error': 'No action'}\\n logger.error('validate_input method: error:{} request:{}'.format(return_data, request))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n if 'east' not in request_data:\\n return_data = {'error': 'No east'}\\n logger.error('validate_input method: error:{} request:{}'.format(return_data, request))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n if 'west' not in request_data:\\n return_data = {'error': 'No west'}\\n logger.error('validate_input method: error:{} request:{}'.format(return_data, request))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n # Debug mode checking condition\\n if 'number' in request_data and 'stops' in request_data:\\n\\n # If current status is break then making debug mode\\n if ValidateError.check_current_status() == 'break':\\n return CreateDebugMode.validate_input_to_create_debug_mode(request_data)\\n\\n # If current status is started or pending then return error_robotworking message\\n elif ValidateError.check_current_status() in ['started', 'pending']:\\n return_data = {'status': 'error', 'error': 'robotworking'}\\n logger.error('validation_errors.check_current_status debug mode method: error:robotworking request:{}'\\n .format(request_data))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n # Else return error_status message\\n else:\\n return_data = {'status': 'error', 'error': 'status'}\\n logger.error('validation_errors.check_current_status debug mode method: error:status unknown request:{}'\\n .format(request_data))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n # Disconnection checking condition\\n elif request_data['action'] == 'disconnect':\\n\\n # If current status is success or revoked or no_uuid then making disconnection\\n if ValidateError.check_current_status() in ['success', 'revoked', 'no_uuid', 'failure']:\\n return CreateDisconnect.validate_input_to_create_disconnection(request_data)\\n\\n # If current status is started or pending or break then return error_robotworking message\\n elif ValidateError.check_current_status() in ['started', 'pending', 'break']:\\n return_data = {'status': 'error', 'error': 'robotworking'}\\n logger.error('validation_errors.check_current_status disconnection method: '\\n 'error:robotworking request:{}'.format(request_data))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n # Else return error_status message\\n else:\\n return_data = {'status': 'error', 'error': 'status'}\\n logger.error('validation_errors.check_current_status disconnection method:'\\n ' error:status unknown request:{}'.format(request_data))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n # Connection checking condition\\n elif request_data['action'] == 'connect':\\n\\n # If current status is success or revoked or no_uuid then making connection\\n if ValidateError.check_current_status() in ['success', 'revoked', 'no_uuid', 'failure']:\\n return CreateConnection.validate_input_to_create_connection(request_data)\\n\\n # If current status is started or pending or break then return error_robotworking message\\n elif ValidateError.check_current_status() in ['started', 'pending', 'break']:\\n return_data = {'status': 'error', 'error': 'robotworking'}\\n logger.error('validation_errors.check_current_status connection method: error:robotworking request:{}'\\n .format(request_data))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n # Else return error_status message\\n else:\\n return_data = {'status': 'error', 'error': 'status unknown'}\\n logger.error('validation_errors.check_current_status connection method: error:status request:{}'\\n .format(request_data))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\\n\\n # Create connection in connection table\\n elif request.data['action'] == 'create_connection':\\n return ConnectionUtilities.create_dummy_connection(request_data)\\n\\n # Else return error_operation message\\n else:\\n return_data = {'status': 'error', 'error': 'operation'}\\n logger.error('validation_errors.check_current_status connection method: error:action unknown request:{}'\\n .format(request_data))\\n return Response(return_data, status=status.HTTP_400_BAD_REQUEST)\",\n \"def _handle_info_response(self, resp, info, prev_info):\\r\\n if info.line_num != prev_info.line_num:\\r\\n return\\r\\n\\r\\n if resp['calltip']:\\r\\n info.editor.show_calltip('Arguments', resp['calltip'],\\r\\n signature=True,\\r\\n at_position=prev_info.position)\\r\\n\\r\\n if resp['name']:\\r\\n self.send_to_inspector.emit(\\r\\n resp['name'], resp['argspec'],\\r\\n resp['note'], resp['docstring'],\\r\\n not prev_info.auto)\",\n \"def valid_properties(self) -> Tuple[str]:\\n tt = self.transaction_type\\n if tt == \\\"GENESIS\\\":\\n return (\\n \\\"token_type\\\",\\n \\\"transaction_type\\\",\\n \\\"lokad_id\\\",\\n \\\"nft_flag\\\",\\n \\\"ticker\\\",\\n \\\"token_name\\\",\\n \\\"token_doc_url\\\",\\n \\\"token_doc_hash\\\",\\n \\\"decimals\\\",\\n \\\"mint_baton_vout\\\",\\n \\\"initial_token_mint_quantity\\\",\\n )\\n elif tt == \\\"MINT\\\":\\n return (\\n \\\"token_type\\\",\\n \\\"transaction_type\\\",\\n \\\"lokad_id\\\",\\n \\\"nft_flag\\\",\\n \\\"token_id\\\",\\n \\\"token_id_hex\\\",\\n \\\"mint_baton_vout\\\",\\n \\\"additional_token_quantity\\\",\\n )\\n elif tt == \\\"SEND\\\":\\n return (\\n \\\"token_type\\\",\\n \\\"transaction_type\\\",\\n \\\"lokad_id\\\",\\n \\\"nft_flag\\\",\\n \\\"token_id\\\",\\n \\\"token_id_hex\\\",\\n \\\"token_output\\\",\\n )\\n elif tt == \\\"COMMIT\\\":\\n return (\\n \\\"token_type\\\",\\n \\\"transaction_type\\\",\\n \\\"lokad_id\\\",\\n \\\"nft_flag\\\",\\n \\\"info\\\",\\n )\\n raise InvalidOutputMessage(\\\"Unknown transaction_type\\\", tt)\",\n \"def InfoCall(connection, functionno, rc):\\n\\n ssl_logging = logging.getLogger('SSL_InfoCall')\\n\\n ssl_logging.debug('In InfoCall')\\n ssl_logging.debug('State : %s' % connection.state_string())\\n ssl_logging.debug('Fuction Number: %s' % functionno)\\n ssl_logging.debug('Return Code : %s' % rc)\\n return 0\",\n \"def response_types(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"response_types\\\")\",\n \"def get_input_output_args(io_info):\\n args = []\\n if io_info is None:\\n return args\\n for item in io_info:\\n if isinstance(item, dict):\\n arg = get_single_io_arg(item)\\n args.append(arg)\\n elif isinstance(item, list):\\n dyn_arg = []\\n for info in item:\\n arg = get_single_io_arg(info)\\n dyn_arg.append(arg)\\n args.append(tuple(dyn_arg))\\n return args\",\n \"def get_input(incoming):\\n try:\\n return incoming.get_output, incoming.get_output_shape()\\n except AttributeError:\\n return lambda **kwargs: incoming, [d if isinstance(d, int) else -1 for d in incoming.get_shape().as_list()]\",\n \"def GetInputCount(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def handle_request(self, query, request):\\r\\n request_pdu = None\\r\\n response_pdu = \\\"\\\"\\r\\n slave_id = None\\r\\n function_code = None\\r\\n func_code = None\\r\\n slave = None\\r\\n response = None\\r\\n\\r\\n try:\\r\\n # extract the pdu and the slave id\\r\\n slave_id, request_pdu = query.parse_request(request)\\r\\n if len(request_pdu) > 0:\\r\\n (func_code, ) = struct.unpack(\\\">B\\\", request_pdu[0])\\r\\n # 43 is Device Information\\r\\n if func_code == 43:\\r\\n # except will throw MissingKeyError\\r\\n slave = self.get_slave(slave_id)\\r\\n response_pdu = slave.handle_request(request_pdu)\\r\\n # make the full response\\r\\n response = query.build_response(response_pdu)\\r\\n # get the slave and let him execute the action\\r\\n elif slave_id == 0:\\r\\n # broadcast\\r\\n for key in self._slaves:\\r\\n response_pdu = self._slaves[key].handle_request(request_pdu, broadcast=True)\\r\\n response = query.build_response(response_pdu)\\r\\n elif slave_id == 255:\\r\\n r = struct.pack(\\\">BB\\\", func_code + 0x80, 0x0B)\\r\\n response = query.build_response(r)\\r\\n else:\\r\\n slave = self.get_slave(slave_id)\\r\\n response_pdu = slave.handle_request(request_pdu)\\r\\n # make the full response\\r\\n response = query.build_response(response_pdu)\\r\\n except (IOError, MissingKeyError) as e:\\r\\n # If the request was not handled correctly, return a server error response\\r\\n r = struct.pack(\\\">BB\\\", func_code + 0x80, defines.SLAVE_DEVICE_FAILURE)\\r\\n response = query.build_response(r)\\r\\n\\r\\n if slave:\\r\\n function_code = slave.function_code\\r\\n\\r\\n return (response, {'request': request_pdu.encode('hex'),\\r\\n 'slave_id': slave_id,\\r\\n 'function_code': function_code,\\r\\n 'response': response_pdu.encode('hex')})\",\n \"def get_req_data(self, data):\\n self.rdata=data\\n if self.rdata == 1 or \\\\\\n self.rdata == 0 or \\\\\\n self.rdata == \\\"\\\":\\n return 1\\n rt=\\\"\\\"\\n for ot in self.rdata.split('\\\\n'):\\n ot = ot.rstrip('\\\\r\\\\n')\\n logging.debug(\\\">>>>>>> Check value of output string: %s\\\" % ot)\\n if not (ot.startswith(\\\"vRA \\\") or \\\\\\n ot.startswith(\\\"JRE Version:\\\") or \\\\\\n ot.startswith(\\\"CloudClient is \\\") or \\\\\\n ot.startswith(\\\"true\\\") or \\\\\\n len(ot) == 0):\\n if ot.startswith(\\\"Error\\\"):\\n print (\\\"Error: %s\\\" % ot.split('Error')[-1])\\n sys.stdout.flush()\\n sys.exit(1)\\n else:\\n logging.debug(\\\"SR# %s\\\" % ot)\\n rt=ot\\n break\\n if not rt:\\n print \\\"No service request is found: %s\\\" % rt\\n return 1\\n else:\\n return rt\",\n \"def command_type(self):\\n if self._is_push_command():\\n command_type = Parser.C_PUSH\\n elif self._is_pop_command():\\n command_type = Parser.C_POP\\n elif self._is_arithmetic_command():\\n command_type = Parser.C_ARITHMETIC\\n elif self._is_comment_line() or self._is_blank_line():\\n command_type = Parser.IGNORE\\n else:\\n command_type = Parser.INVALID\\n return command_type\",\n \"def oic_pre_construct(self, cli_info, request_args=None, **kwargs):\\n for prop in self.msg_type.c_param.keys():\\n if prop in request_args:\\n continue\\n try:\\n request_args[prop] = cli_info.behaviour[prop]\\n except KeyError:\\n pass\\n\\n if \\\"post_logout_redirect_uris\\\" not in request_args:\\n try:\\n request_args[\\n \\\"post_logout_redirect_uris\\\"] = \\\\\\n cli_info.post_logout_redirect_uris\\n except AttributeError:\\n pass\\n\\n if \\\"redirect_uris\\\" not in request_args:\\n try:\\n request_args[\\\"redirect_uris\\\"] = cli_info.redirect_uris\\n except AttributeError:\\n raise MissingRequiredAttribute(\\\"redirect_uris\\\", request_args)\\n\\n try:\\n if cli_info.provider_info[\\n 'require_request_uri_registration'] is True:\\n request_args['request_uris'] = cli_info.generate_request_uris(\\n cli_info.requests_dir)\\n except KeyError:\\n pass\\n\\n return request_args, {}\",\n \"def RequestInformation(self, request, inInfoVec, outInfoVec):\\n from vtkmodules.vtkCommonExecutionModel import vtkStreamingDemandDrivenPipeline as sddp\\n\\n iin = inInfoVec[1].GetInformationObject(0)\\n outInfoVec.GetInformationObject(0).Set(sddp.WHOLE_EXTENT(), iin.Get(sddp.WHOLE_EXTENT()), 6);\\n return 1\",\n \"def get_decoding_op(self):\\n return self._dual.get_op('output')\",\n \"def _check_validconnectioninput(self):\\n # Check if name is valid\\n if self._check_name(self.symbol):\\n second_device = self.symbol\\n self.symbol = self.scanner.get_symbol()\\n # Check if '.' is used:\\n if self._is_period(self.symbol):\\n self.symbol = self.scanner.get_symbol()\\n # Check if device input begins with 'I'\\n if self.names.get_name_string(self.symbol.id)[0] == \\\"I\\\":\\n # Check if input number is a positive number\\n try:\\n inputno = int(\\n self.names.get_name_string(\\n self.symbol.id)[\\n 1:])\\n second_port = self.symbol\\n self.symbol = self.scanner.get_symbol()\\n return second_device, second_port\\n except BaseException:\\n # Input number is not valid\\n self._display_syntax_error(\\\"number\\\")\\n self._semicolon_skipper()\\n return None, None\\n # OR if DType input\\n elif self._check_validdtypeinput(self.symbol):\\n second_port = self.symbol\\n self.symbol = self.scanner.get_symbol()\\n return second_device, second_port\\n else:\\n # Input is not valid\\n self._display_syntax_error(\\\"input\\\")\\n self._semicolon_skipper()\\n return None, None\\n else:\\n # No '.'\\n self._display_syntax_error(\\\"period\\\")\\n self._semicolon_skipper()\\n return None, None\\n else:\\n # Device does not exist\\n self._display_syntax_error(\\\"devicename\\\")\\n self._semicolon_skipper()\\n return None, None\",\n \"def write_operation_type(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"write_operation_type\\\")\",\n \"def write_operation_type(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"write_operation_type\\\")\",\n \"def write_operation_type(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"write_operation_type\\\")\",\n \"def write_operation_type(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"write_operation_type\\\")\",\n \"def print_results(request, response, procedure_name) -> None:\\n procedure_names_dict = {\\n 'SquareRoot': calculator_pb2_grpc.CalculatorServicer.SquareRoot.__name__,\\n 'Square': calculator_pb2_grpc.CalculatorServicer.Square.__name__,\\n }\\n print_string = f\\\"Request: {procedure_names_dict[procedure_name]} for {request.value}.\\\\nResponse: {response.value}.\\\\n\\\"\\n print(print_string)\",\n \"def status_determine():\\n b_status = False\\n b_statusInput = True\\n b_statusAnalyze = True\\n b_statusOutput = True\\n nonlocal dret_inputSet\\n nonlocal dret_analyze\\n nonlocal dret_outputSet\\n nonlocal fn_inputReadCallback\\n nonlocal fn_analysisCallback\\n nonlocal fn_outputWriteCallback\\n\\n if fn_inputReadCallback:\\n if 'status' in dret_inputSet.keys():\\n b_statusInput = dret_inputSet['status']\\n if fn_analysisCallback:\\n if 'status' in dret_analyze.keys():\\n b_statusAnalyze = dret_analyze['status']\\n if fn_outputWriteCallback:\\n if 'status' in dret_outputSet.keys():\\n b_statusOutput = dret_outputSet['status']\\n\\n b_status = b_statusInput and b_statusAnalyze and b_statusOutput\\n return {\\n 'status': b_status\\n }\",\n \"def _dispatch(self, request):\\n endpoint, values, context, param = self.read_request(request)\\n if endpoint == 'init':\\n parse_config(param.get('config', {}))\\n return self.init_info()\\n else:\\n if endpoint == 'provider':\\n return self.call_provider(context, values['name'],\\n values['action'], param)\\n elif endpoint == 'handler':\\n return self.call_handler(context, values['name'], param)\\n else:\\n return self.call_func(context, endpoint, values['name'], param)\",\n \"def call(self, inputs, training=False):\\n prev_merge_mode = self.merge_mode\\n self.set_merge_mode('merge')\\n enc_outputs = self.call_encoder(inputs, training)\\n dec_outputs = self.call_decoder(enc_outputs, training)\\n self.set_merge_mode(prev_merge_mode)\\n\\n return dec_outputs\",\n \"def map_operation(**kwargs):\\n operation = kwargs.get(\\\"data\\\", \\\"\\\")\\n operation_mapper = {\\\"POST\\\": \\\"CREATE\\\"}\\n return operation_mapper.get(operation, operation)\",\n \"def input_or_output(self):\\n return \\\"I\\\"\",\n \"def call(self, inputs):\\n raise NotImplementedError\",\n \"def input_type():\\n pass\",\n \"def _call(*,\\n call,\\n method,\\n headers,\\n params=None,\\n data=None,\\n no_headers=False,\\n json_output=True,\\n raw=False,\\n **kwargs):\\n if not headers and not data and not params and not no_headers:\\n raise AttributeError(\\n 'Asked to do a call to the cloud without valid headers, data or params. This would never work.'\\n )\\n\\n try:\\n if method is requests.put:\\n if data:\\n response = method(call, headers=headers, data=data, timeout=5)\\n else:\\n raise AttributeError('PUT call with no data, this would fail!')\\n elif method is requests.post:\\n if data and params:\\n response = method(call, headers=headers, data=data, params=params, timeout=5)\\n elif data:\\n response = method(call, headers=headers, data=data, timeout=5)\\n elif params:\\n response = method(call, headers=headers, params=params, timeout=5)\\n else:\\n raise AttributeError(\\n 'POST call with no data or params, this probably makes no sense!')\\n\\n elif params:\\n response = method(call, headers=headers, params=params, timeout=5)\\n else:\\n response = method(call, headers=headers, timeout=5)\\n\\n except requests.exceptions.RequestException as e: # pragma: no cover\\n raise ConnectionError(str(e)) from None\\n\\n if response.status_code == 200:\\n if raw:\\n return response\\n if json_output:\\n return response.json()\\n else:\\n return response.text\\n\\n elif response.status_code == 410: # pragma: no cover\\n raise APIError(\\n response.status_code,\\n 'API version outdated. Update python-cozify. {reason} - {url} - {message}'.format(\\n reason=response.reason, url=response.url, message=response.text))\\n else: # pragma: no cover\\n raise APIError(\\n response.status_code, '{reason} - {url} - {message}'.format(reason=response.reason,\\n url=response.url,\\n message=response.text))\",\n \"def external_call( d, output, stack, context ):\\n\\targuments = d[\\\"args\\\"].split(\\\" \\\")\\n\\tstack_collect = stack[-len(arguments):]\\n\\tfor arg, desired in zip(stack_collect, arguments):\\n\\t\\tresult = type_system.type_reduce( arg, desired, output, stack, context )\\n\\t\\tif result != \\\"success\\\":\\n\\t\\t\\treturn \\\"pass\\\"\\n\\toutput.append(\\\" call %s\\\\n\\\" % d[\\\"name\\\"])\\n\\tfor i in arguments:\\n\\t\\tstack.pop()\\n\\tretvals = d[\\\"ret\\\"].split(\\\" \\\")\\n\\tfor val in retvals:\\n\\t\\tstack.append( type_system.Datum( [[val]], [None] ) )\\n\\treturn \\\"success\\\"\",\n \"def form_translate(input_data, operation):\\n \\n # In case you're trying to produce this behavior on the command line for\\n # rapid testing, the command that eventually gets called is: \\n # java -jar form_translate.jar < form.xml > output\\n #\\n # You can pass in a filename or a full string/stream of xml data\\n p = subprocess.Popen([\\\"java\\\",\\\"-jar\\\",\\n config.FORM_TRANSLATE_JAR_LOCATION,\\n operation], \\n shell=False, \\n stdout=subprocess.PIPE,\\n stdin=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n p.stdin.write(input_data)\\n p.stdin.flush()\\n p.stdin.close()\\n \\n output = p.stdout.read() \\n error = p.stderr.read()\\n \\n # todo: this is horrible.\\n has_error = \\\"exception\\\" in error.lower() \\n \\n return {\\\"success\\\": not has_error,\\n \\\"errstring\\\": error,\\n \\\"outstring\\\": output}\",\n \"def _process_info_message(self, message):\\n # Extract the output resolution from the appropriate message, if\\n # it's present.\\n contents = message.get('contents', None)\\n if message['messageCode'] == 'JOB_RUNNING_RESOLUTION':\\n self._resolution = contents['resolutionMs']\\n elif message['messageCode'] == 'FETCH_NUM_TIMESERIES':\\n self._num_input_timeseries += int(message['numInputTimeSeries'])\\n elif message['messageCode'] == 'FIND_MATCHED_NO_TIMESERIES':\\n self._find_matched_no_timeseries = True\\n elif message['messageCode'] == 'FIND_LIMITED_RESULT_SET':\\n self._find_limited_resultset = True\\n self._find_matched_size = contents['matchedSize']\\n self._find_limit_size = contents['limitSize']\\n elif message['messageCode'] == 'GROUPBY_MISSING_PROPERTY':\\n self._group_by_missing_property = True\\n self._group_by_missing_properties = contents['propertyNames']\",\n \"def SendOutputs(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def get_operation_obect(self, method):\\n pass\",\n \"def generate_interface_types(interface, name=None):\\n\\n if not isinstance(interface, type):\\n interface = type(interface)\\n\\n module = interface.__module__\\n\\n method_signatures = {\\n name: MethodSignature.from_method(getattr(interface, name))\\n for name in classes.get_public_method_names(interface)\\n }\\n\\n args_type, types, makers = make_args_type(module, method_signatures)\\n request_type = dataclasses.make_dataclass(\\n (name or interface.__name__) + 'Request',\\n [('args', args_type)],\\n namespace={\\n 'Args': args_type,\\n 'types': types,\\n 'm': makers,\\n },\\n frozen=True,\\n )\\n request_type.__module__ = module\\n\\n result_type = make_result_type(module, method_signatures)\\n error_type = make_error_type(module, interface, method_signatures)\\n response_type = dataclasses.make_dataclass(\\n (name or interface.__name__) + 'Response',\\n [\\n (\\n 'result',\\n typing.Optional[result_type],\\n dataclasses.field(default=None),\\n ),\\n (\\n 'error',\\n typing.Optional[error_type],\\n dataclasses.field(default=None),\\n ),\\n ],\\n namespace={\\n 'Result': result_type,\\n 'Error': error_type,\\n },\\n frozen=True,\\n )\\n response_type.__module__ = module\\n\\n return request_type, response_type\",\n \"def parse_operations(self, operation_type: str) -> Tuple[Operation]:\\n if operation_type is None:\\n return tuple()\\n query_type: SchemaType = self.types.get(operation_type)\\n if query_type is None:\\n return tuple()\\n return tuple([Operation(f, self.settings) for f in query_type.fields])\",\n \"def full_dispatch_request(self):\\n fn = getattr(self, g.action, None)\\n if fn is None:\\n abort(404, 'Unimplemented action %r' % g.action)\\n inputs = self.__class__.schema_inputs.get(g.action)\\n outputs = self.__class__.schema_outputs.get(g.action)\\n output_types = self.__class__.output_types\\n if inputs is not None:\\n (errors, values) = validate(g.request_data, inputs)\\n if errors:\\n return dict(errors), 400\\n else:\\n if isinstance(values, dict):\\n rv = fn(**values)\\n else:\\n rv = fn(values)\\n else:\\n rv = fn()\\n rv, code, headers = unpack(rv)\\n if outputs is not None:\\n (errors, values) = validate(rv, outputs, proxy_types=output_types)\\n if errors:\\n return dict(errors), 500\\n else:\\n rv = values\\n return rv, code, headers\",\n \"def PostInputsNiFi(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def __show_protocol__(self, data):\\n t_16 = t_16_Bit_Options()\\n t_8 = t_8_Bit_Options()\\n t_var = t_8_Bit_Options()\\n print('Received ' + str(len(data)) + ' Bytest')\\n\\n #----------------------------------------------------------------------\\n print('='*80)\\n print('Handling Protocol response: ' + hexlify(data))\\n #----------------------------------------------------------------------\\n print('='*80)\\n print('Overhead Bytes: ' + hexlify(data[:BP_TOOL.OVERHEAD]))\\n print('Number of UINT16 bitstream data = ' + str(data[BP_TOOL.UINT16S]))\\n print('Number of UINT8 bitstream data = ' + str(data[BP_TOOL.UINT8S]))\\n print('Number of var bitstream data = ' + str(data[BP_TOOL.VARS]))\\n print('Follow = ' + str(self.get_follow(data)))\\n print('Length = ' + str(self.get_length(data)))\\n start = self.get_follow_and_length(data)\\n end = start + BP_TOOL.SIZE_FOLLOW + BP_TOOL.SIZE_LEN\\n print('Following bytes and length = ' + hexlify(data[start:end]))\\n #----------------------------------------------------------------------\\n print('='*80)\\n bits = self.get_16bit_options_bits(data)\\n values = self.get_16bit_options(data)\\n options = self.get_options_requested(bits)\\n\\n # Display the options if exist\\n if len(options):\\n print('UINT16 bits...... : ' + hexlify(bits))\\n print('UINT16 data...... : ' + hexlify(values))\\n print('UINT16 Num of opts ... : ' + str(len(values) // 2))\\n print('UINT16 options... : ' + str(options))\\n print('-'*80)\\n for x in range(len(options)):\\n value = (values[x*2] << 8) | (values[x*2 + 1])\\n opt = options[x]\\n t_16.set_value(opt, value)\\n print('Option: ' + t_16.options[opt]['name'] + ' ' + str(value))\\n pprint.pprint(t_16.options)\\n else:\\n print('No 16 bit options')\\n\\n #----------------------------------------------------------------------\\n print('-'*80)\\n bits = self.get_8bit_options_bits(data)\\n values = self.get_8bit_options(data)\\n options = self.get_options_requested(bits)\\n # Display the options if exist\\n if len(options):\\n print('UINT8 bits...... : ' + hexlify(bits))\\n print('UINT8 data...... : ' + hexlify(values))\\n print('UINT8 options... : ' + str(options))\\n print('-'*80)\\n for x in range(len(options)):\\n value = values[x]\\n opt = options[x]\\n t_8.set_value(opt, value)\\n print('Option: ' + t_8.options[x]['name'] + ' ' + str(value))\\n pprint.pprint(t_8.options)\\n else:\\n print('No 8 bit options')\\n\\n #----------------------------------------------------------------------\\n print('-'*80)\\n bits = self.get_var_options_bits(data)\\n values = self.get_var_options(data)\\n print('VARS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')\\n # Display the options if exist\\n if len(values):\\n pprint.pprint(values)\\n else:\\n print('No var bit options')\\n\\n print('VAR options... : ' + str(self.get_options_requested(bits)))\\n print('VARS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')\\n print('-'*80)\",\n \"def _process_ok_response(self, bis, request):\\n #\\n # this call gives the Request an opinion on which serial version\\n # to use\\n #\\n version = request.get_serial_version(self._client.serial_version)\\n if version <= 3:\\n # V3 and earlier protocols start with an error byte (0 is no error)\\n code = bis.read_byte()\\n else:\\n # V4 starts with an NSON MAP. If the type is correct then treat it\\n # as a V4 response. If it's not correct then it's a V3\\n # error code from a V3 proxy. If it's a V4 map, code will be 0\\n code = SerdeUtil.check_for_map(bis)\\n if code == 0:\\n res = request.create_serializer(version).deserialize(\\n request, bis, version)\\n if request.is_query_request():\\n if not request.is_simple_query():\\n request.get_driver().set_client(self._client)\\n return res\\n\\n \\\"\\\"\\\"\\n Operation failed. Handle the failure and throw an appropriate\\n exception.\\n \\\"\\\"\\\"\\n err = SerdeUtil.read_string(bis)\\n\\n # special case for TNF errors on WriteMultiple with many tables\\n if code == SerdeUtil.USER_ERROR.TABLE_NOT_FOUND and \\\\\\n isinstance(request, operations.WriteMultipleRequest):\\n raise self._handle_write_multiple_table_not_found(code, err, request)\\n\\n raise SerdeUtil.map_exception(code, err)\",\n \"def parse_request(self, request):\\n response=''\\n http_code = 200\\n\\n request_line = request.splitlines()[0]\\n request_method, path, request_version = request_line.split()\\n\\n #Try to split path into it's components: the operation requested and the keyvalue\\n try:\\n request_op, request_keyvalue = path.split('?')\\n request_op = request_op[1:]\\n\\n #If request is a get we split in a different order than if it's a set\\n if request_op == 'get':\\n request_value, request_key = request_keyvalue.split('=')\\n response, http_code = self.get_value(request_key)\\n elif request_op == 'set':\\n request_key, request_value = request_keyvalue.split('=')\\n response, http_code = self.set_value(request_key, request_value)\\n else:\\n response = 'Unknown operation in URL. Must be either GET or SET.'\\n http_code = 400\\n\\n except ValueError: #Catch any paths that don't match the form we're interested in\\n response = dedent(\\\"\\\"\\\"Incorrect path (%s)\\n Requested URL must take the form http://%s:%s/[operation]?[value]\\\"\\\"\\\" % (path, self.server_address, self.server_port))\\n http_code = 400\\n return response, http_code\\n\\n return response, http_code\",\n \"def visit_Call(self, node: ast.Call) -> None:\\n self._check_open_call_context(node)\\n self._check_type_compare(node)\\n self._check_range_len(node)\\n self.generic_visit(node)\",\n \"def check_request(self, params, permission):\\n exception = {}\\n\\n if permission.get('qgs_project') is None:\\n # service unknown or not permitted\\n exception = {\\n 'code': \\\"Service configuration error\\\",\\n 'message': \\\"Service unknown or unsupported\\\"\\n }\\n elif not params.get('REQUEST'):\\n # REQUEST missing or blank\\n exception = {\\n 'code': \\\"OperationNotSupported\\\",\\n 'message': \\\"Please check the value of the REQUEST parameter\\\"\\n }\\n else:\\n service = params.get('SERVICE', '')\\n request = params.get('REQUEST', '').upper()\\n\\n if service == 'WMS' and request == 'GETFEATUREINFO':\\n # check info format\\n info_format = params.get('INFO_FORMAT', 'text/plain')\\n if re.match('^application/vnd.ogc.gml.+$', info_format):\\n # do not support broken GML3 info format\\n # i.e. 'application/vnd.ogc.gml/3.1.1'\\n exception = {\\n 'code': \\\"InvalidFormat\\\",\\n 'message': (\\n \\\"Feature info format '%s' is not supported. \\\"\\n \\\"Possibilities are 'text/plain', 'text/html' or \\\"\\n \\\"'text/xml'.\\\"\\n % info_format\\n )\\n }\\n elif service == 'WMS' and request == 'GETPRINT':\\n # check print templates\\n template = params.get('TEMPLATE')\\n if template and template not in permission['print_templates']:\\n # allow only permitted print templates\\n exception = {\\n 'code': \\\"Error\\\",\\n 'message': (\\n 'Composer template not found or not permitted'\\n )\\n }\\n\\n if not exception:\\n # check layers params\\n\\n # lookup for layers params by request\\n # {\\n # : {\\n # : [\\n # , \\n # ]\\n # }\\n # }\\n ogc_layers_params = {\\n 'WMS': {\\n 'GETMAP': ['LAYERS', None],\\n 'GETFEATUREINFO': ['LAYERS', 'QUERY_LAYERS'],\\n 'GETLEGENDGRAPHIC': [None, 'LAYER'],\\n 'GETLEGENDGRAPHICS': [None, 'LAYER'], # QGIS legacy request\\n 'DESCRIBELAYER': [None, 'LAYERS'],\\n 'GETSTYLES': [None, 'LAYERS']\\n },\\n 'WFS': {\\n 'DESCRIBEFEATURETYPE': ['TYPENAME', None],\\n 'GETFEATURE': [None, 'TYPENAME']\\n }\\n }\\n\\n layer_params = ogc_layers_params.get(service, {}).get(request, {})\\n\\n if service == 'WMS' and request == 'GETPRINT':\\n # find map layers param for GetPrint (usually 'map0:LAYERS')\\n for key, value in params.items():\\n if key.endswith(\\\":LAYERS\\\"):\\n layer_params = [key, None]\\n break\\n\\n if layer_params:\\n permitted_layers = permission['public_layers']\\n filename = params.get('FILENAME', '')\\n if (service == 'WMS' and (\\n (request == 'GETMAP' and filename) or request == 'GETPRINT'\\n )):\\n # When doing a raster export (GetMap with FILENAME)\\n # or printing (GetPrint), also allow background layers\\n permitted_layers += permission['background_layers']\\n if layer_params[0] is not None:\\n # check optional layers param\\n exception = self.check_layers(\\n layer_params[0], params, permitted_layers, False\\n )\\n if not exception and layer_params[1] is not None:\\n # check mandatory layers param\\n exception = self.check_layers(\\n layer_params[1], params, permitted_layers, True\\n )\\n\\n return exception\",\n \"def _check_validconnectionoutput(self):\\n # Check if name is valid and has been initialised\\n if self._check_name(self.symbol):\\n first_device = self.symbol\\n self.symbol = self.scanner.get_symbol()\\n # Check if '->' is used\\n if self._is_arrow(self.symbol):\\n return first_device, None\\n elif self._is_period(self.symbol):\\n self.symbol = self.scanner.get_symbol()\\n if self._check_validdtypeoutput(self.symbol):\\n first_port = self.symbol\\n self.symbol = self.scanner.get_symbol()\\n return first_device, first_port\\n else:\\n # Invalid DType output\\n self._display_syntax_error(\\\"doutput\\\")\\n self._semicolon_skipper()\\n return None, None\\n else:\\n # Neither an arrow nor a DType output\\n self._display_syntax_error(\\\"arrowperiod\\\")\\n self._semicolon_skipper()\\n return None, None\\n else:\\n # Device does not exist\\n self._display_syntax_error(\\\"devicename\\\")\\n self._semicolon_skipper()\\n return None, None\",\n \"def StreamInputs(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def guess_calling_convention(self):\\n return calldef_types.CALLING_CONVENTION_TYPES.UNKNOWN\",\n \"def getsolutioninfo(self,whichsol_): # 3\\n if not isinstance(whichsol_,soltype): raise TypeError(\\\"Argument whichsol has wrong type\\\")\\n res,resargs = self.__obj.getsolutioninfo(whichsol_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n _pobj_return_value,_pviolcon_return_value,_pviolvar_return_value,_pviolbarvar_return_value,_pviolcone_return_value,_pviolitg_return_value,_dobj_return_value,_dviolcon_return_value,_dviolvar_return_value,_dviolbarvar_return_value,_dviolcone_return_value = resargs\\n return _pobj_return_value,_pviolcon_return_value,_pviolvar_return_value,_pviolbarvar_return_value,_pviolcone_return_value,_pviolitg_return_value,_dobj_return_value,_dviolcon_return_value,_dviolvar_return_value,_dviolbarvar_return_value,_dviolcone_return_value\",\n \"def getOperationMetadata(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\"\n]"},"negative_scores":{"kind":"list like","value":["0.5174658","0.5018817","0.4834404","0.47635424","0.4631196","0.46073565","0.45646647","0.45536888","0.4535534","0.45211482","0.44949257","0.4465704","0.44512537","0.4426451","0.44040138","0.44033703","0.43914264","0.43877032","0.4385859","0.43828747","0.43793657","0.43721932","0.43482167","0.43448585","0.43419588","0.4333053","0.43312353","0.43153423","0.430005","0.4298266","0.4298266","0.4285821","0.4282567","0.42745984","0.42703947","0.4267555","0.4266104","0.42545578","0.42513797","0.4249028","0.42391375","0.42360276","0.4233659","0.42255718","0.4224528","0.42235708","0.4218548","0.42155606","0.42153934","0.42153934","0.42153436","0.42152348","0.42145038","0.42096385","0.42071396","0.42040783","0.41933978","0.41911128","0.41905853","0.41853023","0.4180585","0.4174984","0.41718042","0.41696757","0.41683215","0.4164832","0.41639182","0.41632143","0.4160123","0.4160123","0.4160123","0.4160123","0.4155205","0.41499013","0.4143705","0.41330612","0.41322654","0.4130583","0.4127633","0.4124138","0.4114674","0.4114665","0.41135204","0.41077372","0.41022998","0.4100404","0.40995762","0.40990332","0.4098139","0.40882084","0.40859428","0.40825382","0.40824807","0.4080589","0.4079259","0.40771422","0.4072683","0.40718368","0.40690076","0.4066481"],"string":"[\n \"0.5174658\",\n \"0.5018817\",\n \"0.4834404\",\n \"0.47635424\",\n \"0.4631196\",\n \"0.46073565\",\n \"0.45646647\",\n \"0.45536888\",\n \"0.4535534\",\n \"0.45211482\",\n \"0.44949257\",\n \"0.4465704\",\n \"0.44512537\",\n \"0.4426451\",\n \"0.44040138\",\n \"0.44033703\",\n \"0.43914264\",\n \"0.43877032\",\n \"0.4385859\",\n \"0.43828747\",\n \"0.43793657\",\n \"0.43721932\",\n \"0.43482167\",\n \"0.43448585\",\n \"0.43419588\",\n \"0.4333053\",\n \"0.43312353\",\n \"0.43153423\",\n \"0.430005\",\n \"0.4298266\",\n \"0.4298266\",\n \"0.4285821\",\n \"0.4282567\",\n \"0.42745984\",\n \"0.42703947\",\n \"0.4267555\",\n \"0.4266104\",\n \"0.42545578\",\n \"0.42513797\",\n \"0.4249028\",\n \"0.42391375\",\n \"0.42360276\",\n \"0.4233659\",\n \"0.42255718\",\n \"0.4224528\",\n \"0.42235708\",\n \"0.4218548\",\n \"0.42155606\",\n \"0.42153934\",\n \"0.42153934\",\n \"0.42153436\",\n \"0.42152348\",\n \"0.42145038\",\n \"0.42096385\",\n \"0.42071396\",\n \"0.42040783\",\n \"0.41933978\",\n \"0.41911128\",\n \"0.41905853\",\n \"0.41853023\",\n \"0.4180585\",\n \"0.4174984\",\n \"0.41718042\",\n \"0.41696757\",\n \"0.41683215\",\n \"0.4164832\",\n \"0.41639182\",\n \"0.41632143\",\n \"0.4160123\",\n \"0.4160123\",\n \"0.4160123\",\n \"0.4160123\",\n \"0.4155205\",\n \"0.41499013\",\n \"0.4143705\",\n \"0.41330612\",\n \"0.41322654\",\n \"0.4130583\",\n \"0.4127633\",\n \"0.4124138\",\n \"0.4114674\",\n \"0.4114665\",\n \"0.41135204\",\n \"0.41077372\",\n \"0.41022998\",\n \"0.4100404\",\n \"0.40995762\",\n \"0.40990332\",\n \"0.4098139\",\n \"0.40882084\",\n \"0.40859428\",\n \"0.40825382\",\n \"0.40824807\",\n \"0.4080589\",\n \"0.4079259\",\n \"0.40771422\",\n \"0.4072683\",\n \"0.40718368\",\n \"0.40690076\",\n \"0.4066481\"\n]"},"document_score":{"kind":"string","value":"0.73895764"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":1697,"cells":{"query":{"kind":"string","value":"Returns typecodes representing a parameter set parameters list of WSDLTools.ParameterInfo instances representing the parts of a WSDL Message."},"document":{"kind":"string","value":"def _getTypeCode(self, parameters, literal=False):\r\n ofwhat = []\r\n for part in parameters:\r\n namespaceURI,localName = part.type\r\n\r\n if part.element_type:\r\n #global element\r\n element = self._wsdl.types[namespaceURI].elements[localName]\r\n tc = self._getElement(element, literal=literal, local=False, namespaceURI=namespaceURI)\r\n else:\r\n #local element\r\n name = part.name\r\n typeClass = self._getTypeClass(namespaceURI, localName)\r\n if not typeClass:\r\n tp = self._wsdl.types[namespaceURI].types[localName]\r\n tc = self._getType(tp, name, literal, local=True, namespaceURI=namespaceURI)\r\n else:\r\n tc = typeClass(name)\r\n ofwhat.append(tc)\r\n return ofwhat"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parameterTypes(self, p_int): # real signature unknown; restored from __doc__\n return []","def getParamsType(self):\n\t\treturn [\"int\", \"int\"]","def parameterNames(self, p_int): # real signature unknown; restored from __doc__\n return []","def _fi_in_parameters(self) -> List[Tuple[str, str]]:\n result = list() # type: List[Tuple[str, str]]\n for param in self.params:\n type_list = param.fi_type()\n for type_name, postfix in type_list:\n result.append((type_name, param.name + postfix))\n return result","def _f_in_parameters(self) -> List[Tuple[str, str]]:\n result = list() # type: List[Tuple[str, str]]\n for param in self.params:\n type_list = param.f_type()\n for type_name, postfix in type_list:\n result.append((type_name, param.name + postfix))\n return result","def parameter_names(self) -> List[str]:","def _fc_in_parameters(self) -> List[str]:\n result = list() # type: List[str]\n\n for param in self.params:\n type_list = param.fc_type()\n for type_name, postfix in type_list:\n result.append('{} {}'.format(type_name, param.name + postfix))\n\n return result","def build_parameters(self) -> List[str]:\n param_bits = []\n for name in self.parameters:\n param_bits.extend(self.build_parameter_by_name(name) or [])\n return param_bits","def generate_parameter_map(rpc_blocks, full_signature, param_values):\n parameter_map = []\n list_object_pattern = re.compile(\n r\"(java\\.util\\.(?:[A-Za-z]+)?List(?:[0-9/]+)?)<([a-zA-Z0-9./]+)[<>]?(?:(.*[^>]))?>\"\n )\n\n # Append type index for each parameter value\n for i, param in enumerate(param_values):\n param_type = full_signature[i]\n\n # If parameter is of type list, append index of list type\n if re.match(list_object_pattern, param_type):\n list_type = re.findall(list_object_pattern, param_type)[0][0]\n parameter_map.append(str(rpc_blocks.index(list_type) - 2))\n\n # If not of type list, appeand index of simple type\n else:\n parameter_map.append(str(rpc_blocks.index(full_signature[i]) - 2))\n\n # For each indexed parameter append type and value indicies\n for i, param in enumerate(param_values):\n param_type = full_signature[i]\n\n # If parameter is a string object, append value index\n if param_type.startswith(COMPLEX_TYPES[\"STRING\"]):\n parameter_map.append(str(rpc_blocks.index(param) - 2))\n\n # Else if the parameter is simple type, append value\n elif param_type in SIMPLE_TYPES.keys():\n parameter_map.append(str(param))\n\n # Else if the parameter is a java list object, append type index and length\n elif re.match(list_object_pattern, param_type):\n list_length = 1\n list_type = list(filter(None, re.findall(list_object_pattern, param_type)[0]))\n\n parameter_map.append(\n str(rpc_blocks.index(list_type[0] if len(list_type) < 3 else list_type[1]) - 2)\n )\n parameter_map.append(str(list_length))\n\n # For each element of the list, append type and value indicies\n for _ in range(list_length):\n parameter_map.append(\n str(rpc_blocks.index(list_type[1] if len(list_type) < 3 else list_type[2]) - 2)\n )\n parameter_map.append(str(rpc_blocks.index(param) - 2))\n\n # If parameter is a so far unhandled complex type, append runtime index and value\n elif any(\n param_type.startswith(val)\n for val in COMPLEX_TYPES.values()\n ):\n parameter_map.append(str(rpc_blocks.index(param_type) - 2))\n parameter_map.append(str(param))\n\n # If parameter is unknown, append runtime index and value index\n else:\n parameter_map.append(str(rpc_blocks.index(param_type) - 2))\n parameter_map.append(str(rpc_blocks.index(param) - 2))\n\n return parameter_map","def getParameterList(self):\n inputList = []\n for name, n in zip(self._names, self._inputs):\n inputList += ['%s.x%d' % (name, i) for i in range(n)]\n return inputList","def params(self):\n params = []\n\n for item in self._definition.get('params', []):\n params.append(Parameter(**item))\n\n return params","def _get_parameters(self):\n return (self.SYMBOL, self.parameterArray())","def get_method_parameter_values(code, line, full_sig):\n param_list = []\n offset = int((get_offset(code, line, \"catch(\") - 3))\n line += (1 + int(offset / 2))\n\n for i in range(int(offset / 2)):\n param_pattern = re.compile(rf\", ?(?:'' ?\\+ ?)?(?:{R_VAR}\\(?.*, ?)?(.*[^\\)])\\)\\)?;\")\n nested_boolean_pattern = re.compile(rf\".*\\?(('?{R_VAR}'?):('?{R_VAR}'?))\")\n param = re.findall(param_pattern, code[line])[0].replace(\"'\", \"\")\n\n # if parameter is boolean, append 0\n if (\n nested_boolean_pattern.search(code[line])\n or full_sig[i].startswith(COMPLEX_TYPES[\"BOOLEAN\"])\n ):\n param_list.append(\"§0§\")\n\n # if parameter is numeric, append directly\n elif is_number(param) or full_sig[i].startswith(\"I\"):\n param_list.append(f\"§{param if is_number(param) else randint(0,99)}§\")\n\n # else, treat as tring and append with previx\n else:\n param = param.replace(\" \", \"_\").replace(\"|\", \"\\\\!\").replace(\"\\\\\", \"\\\\\\\\\")\n param_list.append(f\"§param_{param}§\")\n line += 1\n\n return param_list","def parameters_list(self):\n return [getattr(self.parameters, p) for p in self.parameters_names()]","def Params(self):\n params = list()\n if self.currtok[1].name in {\"INT\", \"FLOAT\", \"BOOLEAN\"}:\n type = self.Type()\n self.ids[self.currtok[0]] = type\n id = self.primary()\n par = Param(type, id)\n params.append(par)\n while self.currtok[1].name in {\"COMMA\"}:\n self.currtok = next(self.tg)\n type = self.Type()\n self.ids[self.currtok[0]] = type\n id = self.primary()\n par = Param(type, id)\n params.append(par)\n return Params(params)","def params(self) -> Tuple[Parameter, ...]:\n raise NotImplementedError()","def classifyParameters(self):\n\n arguments = []\n options = []\n outputs = []\n for parameter in self.parameters():\n if parameter.channel == 'output' and not (\n parameter.isExternalType() or parameter.typ == 'file'):\n outputs.append(parameter)\n elif parameter.index is not None:\n arguments.append(parameter)\n if parameter.flag is not None or parameter.longflag is not None:\n logger.warning(\"Parameter %s has both index=%d and flag set.\" % (\n parameter.identifier(), parameter.index))\n else:\n options.append(parameter)\n arguments.sort(key = lambda parameter: parameter.index)\n return (arguments, options, outputs)","def get_parameters(self, doc, type_table):\n scraper = TypeScraper(type_table=type_table)\n r = docscrape.NumpyDocString(doc)\n paras = {}\n for p in r['Parameters']:\n\n para_str = str(p.type)\n para_type = scraper.scrap(para_str)\n if self.is_valid_para(para_type, type_table):\n paras[p.name] = scraper.scrap(para_str)\n else:\n continue\n return paras","def parameter(self):\n res = dict()\n for x in self._desc.fields:\n if x.type == FieldDescriptor.TYPE_MESSAGE:\n parameter = ParameterGroup(x)\n elif x.type == FieldDescriptor.TYPE_ENUM:\n parameter = ParameterEnum(x)\n else:\n parameter = ParameterPrimitive(x)\n\n res[x.name] = parameter\n\n return res","def __parameters__(self) -> tuple[TypeVar, ...]:\n return super().__getattribute__(\"_parameters\")","def compile_parameter_list(self):\r\n if self.__tokenizer.token_type() != TYPES_DIC[\"SYMBOL\"]:\r\n type = self.__get_type()\r\n self.__advance()\r\n name = self.__tokenizer.identifier()\r\n self.__subroutine_symbols.define(name, type, \"argument\")\r\n self.__advance()\r\n while self.__tokenizer.symbol() != ')':\r\n self.__advance()\r\n type = self.__get_type()\r\n self.__advance()\r\n name = self.__tokenizer.identifier()\r\n self.__subroutine_symbols.define(name, type, \"argument\")\r\n self.__advance()","def parameters(self):\n return []","def _get_parameters(self) -> list:\n return self.parameters","def parameter_names(self) -> list:\n parameters = []\n parameters.extend(self.properties.parameter_names)\n return parameters","def get_parameters(self):\n result = self.generate_parameters()\n id, vector = result\n if not vector:\n return id, vector\n\n params = {}\n for idx in range(len(self.param_names)):\n name = self.param_names[idx]\n settings = self.param_settings[idx]\n value = vector[idx]\n if settings['type'] == \"int\":\n value = int(round(value))\n elif settings['type'] == \"float\":\n value = float(value)\n params[name] = value\n return id, params","def parameters(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Statement.Declaration]:","def getTypeCode(self):\n return _libsbml.Parameter_getTypeCode(self)","def get_ext_param_descriptions(self):\n num_param = core.xc_func_info_get_n_ext_params(self.xc_func_info)\n\n ret = []\n for p in range(num_param):\n tmp = core.xc_func_info_get_ext_params_description(self.xc_func_info, p)\n ret.append(tmp.decode(\"UTF-8\"))\n\n return ret","def param(self):\r\n\r\n return []","def parameters(self) -> List[Parameter]:\n return self._parameters","def _declare_parameters(self):\n def to_modelica(arg):\n \"\"\" Convert to Modelica array.\n \"\"\"\n # Check for strings and booleans\n if isinstance(arg, str):\n return '\\\\\"' + arg + '\\\\\"'\n elif isinstance(arg, bool):\n if arg is True:\n return 'true'\n else:\n return 'false'\n try:\n return '{' + \", \".join(to_modelica(x) for x in arg) + '}'\n except TypeError:\n return repr(arg)\n dec = list()\n\n for k, v in list(self._parameters_.items()):\n # Dymola requires vectors of parameters to be set in the format\n # p = {1, 2, 3} rather than in the format of python arrays, which\n # is p = [1, 2, 3].\n # Hence, we convert the value of the parameter if required.\n s = to_modelica(v)\n dec.append('{param}={value}'.format(param=k, value=s))\n\n return dec","def get_parameter_descriptions(parameters):\n\n lines = []\n opt_lines = []\n for param in parameters:\n param_name = check_param(flatten_param(param['name']))\n if param['required']:\n required = 'required'\n lines.append(':param {0}: ({1}) {2}'.format(param_name, required,\n param['description']))\n lines.append(':type {0}: {1}'.format(param_name, param['type']))\n else:\n required = 'optional'\n opt_lines.append(':param {0}: ({1}) {2}'.format(param_name,\n required, param['description']))\n opt_lines.append(':type {0}: {1} or None'.format(param_name,\n param['type']))\n\n return lines + opt_lines","def params(self):\n return tuple(self._params)","def param(self):\n return []","def param(self):\n return []","def parameter_values(self) -> List[Tuple[str, Any]]:\n pvs = [(param, getattr(self, variable))\n for variable, param in self.variable_name_to_query_param.items()]\n return [(p, v) for p, v in pvs if v is not None]","def param_strs(self):\n name_len = max(len(p.name) for p in self)\n value_len = max(len(p.value_str) for p in self.params.values())\n units_len = max(len(p.units) for p in self.params.values())\n return [(p.name.ljust(name_len), p.value_str.ljust(value_len),\n p.units.ljust(units_len), p.__doc__)\n for p in self.params.values() if p]","def parameters(self):\n params = []\n for layer in (self.conv1, self.conv2, self.conv3, self.conv4, self.dense1, self.dense2):\n params += list(layer.parameters)\n return params","def parameters(self):\n return [p for _, a in vars(self).items() for p in self._params(a)]","def decode(self):\n # make a copy since in case of XML it could be necessary to modify\n # the raw_params - filter out elements different than params\n raw_params = deepcopy(self.raw_params)\n params_def = self.params_def\n # ignore other tags than \"param\" and \"paramRepeat\"\n # e.g. sequencer may create tags like \"hookPlace\"\n if isinstance(raw_params, etree._Element):\n for raw_param in raw_params:\n if not raw_param.tag in (\"param\", \"paramrepeat\"):\n raw_params.remove(raw_param)\n\n params = []\n # check if too many parameters were passed\n len_params_def = len(params_def)\n if len(raw_params) > len_params_def:\n msg = (\"%r are supernumerary with respect to definition\" %\n raw_params[len_params_def:])\n raise SupernumeraryParam, msg\n # iterate over definition since missing values may just mean using\n # the default values\n for i, param_def in enumerate(params_def):\n try:\n raw_param = raw_params[i]\n except IndexError:\n raw_param = None\n obj = self.decodeNormal(raw_param, param_def)\n params.append(obj)\n self.params = params\n return self.params","def typeParameters():\n\t\td = AdaptiveBatAlgorithm.typeParameters()\n\t\td.pop('A', None), d.pop('r', None)\n\t\td.update({\n\t\t\t'A_l': lambda x: isinstance(x, (float, int)) and x >= 0,\n\t\t\t'A_u': lambda x: isinstance(x, (float, int)) and x >= 0,\n\t\t\t'r_l': lambda x: isinstance(x, (float, int)) and x >= 0,\n\t\t\t'r_u': lambda x: isinstance(x, (float, int)) and x >= 0,\n\t\t\t'tao_1': lambda x: isinstance(x, (float, int)) and 0 <= x <= 1,\n\t\t\t'tao_2': lambda x: isinstance(x, (float, int)) and 0 <= x <= 1\n\t\t})\n\t\treturn d","def getListOfParameters(self):\n return self.model.getListOfParameters()","def param(self):\r\n return []","def parameters_names(cls):\n return cls._Parameters._fields","def getParameters(self): #$NON-NLS-1$\r","def identifiers(self):\n identifiers = []\n\n for item in self._definition.get('identifiers', []):\n identifiers.append(Parameter(**item))\n\n return identifiers","def get_params(node):\n if node.type == 'parameter':\n return [(self.descend(node.args[0]), types.translation[self.descend(node.args[1])])]\n else:\n l = []\n for p in node.args:\n l.extend(get_params(p))\n return l","def get_parameters_list(self):\n return self.description[\"config\"][\"values\"].keys()","def get_parameter_names(self):\n parNames = []\n # for par in self.variables: # TODO: LIKELY A BUG! DOES THE SAME AS get_variable_names()\n for par in self.parameters: # TRYING TO SOLVE THE ISSUE\n # EstimationVariable\n parNames.append(par.name)\n return parNames","def get_design_parameters(self):\n return self.__get_one_type_params(DesignParameter)","def generate_parameters(self):\n id = len(self.param_values)\n\n vector = []\n \n for idx in range(len(self.param_names)):\n name = self.param_names[idx]\n value = None\n settings = self.param_settings[idx]\n new_value = self.get_next_parameter(name, value, settings, id=id)\n vector.append(self.clamp(new_value, settings['min'], settings['max']))\n\n self.param_values.append(vector)\n self.result.append(None)\n return id, vector","def parameters(self):\n return {\"P\": self.P,\n \"T\": self.T}","def get_param_names(self):\n return list(self.params.keys())","def params(self) -> List[ParamSpec]:\n return self._params","def compile_parameter_list(self):\r\n var_type = None\r\n while True:\r\n self.tokenizer.advance()\r\n tok_type = self.tokenizer.token_type()\r\n if tok_type == JackTokenizer.KEYWORD_T:\r\n var_type = self.tokenizer.key_word()\r\n elif tok_type == JackTokenizer.IDENTIFIER_T:\r\n if not var_type:\r\n var_type = self.tokenizer.identifier()\r\n else:\r\n var_name = self.tokenizer.identifier()\r\n self.symbol_table.define(var_name, var_type, SymbolTable.ARG)\r\n var_type = None\r\n else:\r\n sym = self.tokenizer.symbol()\r\n if sym == \")\":\r\n break","def getTypeCode(self):\n return _libsbml.LocalParameter_getTypeCode(self)","def get_parameter_declarations(self, root):\n param_declare_group = etree.SubElement(root, \"ParameterDeclarations\")\n if QgsProject.instance().mapLayersByName(\"Parameter Declarations\"):\n param_layer = QgsProject.instance().mapLayersByName(\"Parameter Declarations\")[0]\n for feature in param_layer.getFeatures():\n param_name = feature[\"Parameter Name\"]\n param_type = feature[\"Type\"]\n param_value = feature[\"Value\"]\n\n param = etree.SubElement(param_declare_group, \"ParameterDeclaration\")\n param.set(\"name\", param_name)\n param.set(\"type\", param_type)\n param.set(\"value\", param_value)","def compile_params(parameters):\n return tuple(p.values()[0] for p in parameters[1:])","def get_paginator_parameters(self, paginator):\n fields = []\n if hasattr(paginator, 'get_schema_fields'):\n fields = paginator.get_schema_fields(self.view)\n\n return [self.coreapi_field_to_parameter(field) for field in fields]","def get_field_parameters(self, in_parms):\n if len(in_parms) == 0: # Check if there are params\n return None # If that's the case, return None\n\n values = [] # Empty values\n is_msg = False # Check if the param is a message\n for parm in in_parms: # Loop over params\n if parm.type == \"Field\": # If it is a message\n is_msg = True # Set is_message to true\n continue # Go to top of loop\n _type = eval(parm.type) # create a type object\n value = _type(parm.value) # Create the value, and cast it to the type\n values.append(value) # Add that into the parameters\n if is_msg is True: # check if is a message\n return in_parms # Return input params\n elif len(values) == 1: # If there is only one element\n return values[-1] # Return just that element\n else: # Otherwise\n return values # Return the params","def split_params(self, params):\n\t\tindex = 0\n\t\tacc = ''\n\t\tret = [] #return value (is ret a bad name?)\n\t\twhile index < len(params):\n\t\t\tif params[index] == ',': #End of a parameter\n\t\t\t\tret.append(acc)\n\t\t\t\tacc = ''\n\t\t\telif params[index] == '(': #start of a type that is a function\n\t\t\t\tend = params.match_paren(index)\n\t\t\t\twhile index <= end: #so the commas in the function type\n\t\t\t\t\t# are disregarded\n\t\t\t\t\tacc += params[index]\n\t\t\t\t\tindex += 1\n\t\t\t\tcontinue #so index doesn't get incremented again\n\t\t\telse:\n\t\t\t\tacc += params[index]\n\t\t\tindex += 1\n\n\t\tif acc: #if they ended the list with a comma then acc would be ''\n\t\t\tret.append(acc) #parameters not ended with a comma,\n\t\t\t# acc last the last param\n\n\t\treturn ret","def _fi_out_parameters(self) -> Tuple[str, List[Tuple[str, str]]]:\n out_pars = self.ret_type.fi_ret_type()\n if len(out_pars) == 1:\n return (out_pars[0][0], [])\n\n out_par_list = list() # type: List[Tuple[str, str]]\n for par_type, par_name in out_pars:\n out_par_list.append((par_type, 'ret_val' + par_name))\n\n return ('', out_par_list)","def extract_method_signature(code, line):\n line += 5\n method_signature = []\n offset = get_offset(code, line, \"catch(\")\n param_pattern = re.compile(rf\"{R_VAR}\\(.*, ?.*, ?(.*)\\)\\);\")\n\n for _ in range(int((offset - 2) / 2)):\n parameter = parse_parameter(code, re.findall(param_pattern, code[line])[0])\n\n # If List type found, assume ArrayList implementation of Strings\n if parameter.startswith(COMPLEX_TYPES[\"LIST\"]):\n parameter += f\"<{COMPLEX_TYPES['ARRAY']}/4159755760\"\n parameter += f\"<{COMPLEX_TYPES['STRING']}/2004016611>>\"\n\n # If specific List implementation found, assume it is of Strings\n elif re.match(r\"java\\.util\\.[A-Za-z]+List/.*\", parameter):\n parameter += f\"<{COMPLEX_TYPES['STRING']}/2004016611>\"\n\n method_signature.append(parameter)\n\n line += 1\n\n return method_signature","def getListOfParameters(self, *args):\n return _libsbml.Model_getListOfParameters(self, *args)","def params(self):\n if isinstance(self.request, list):\n return unmunchify(self.request)\n (params, _) = xmlrpc.loads(self.request)\n return params","def get_parameters(parameters):\n\n arg_list = []\n opt_list = []\n for param in parameters:\n param_name = param['name']\n param_required = param['required']\n if param_required:\n arg_list.append(format_parameter(param_name, param_required))\n else:\n opt_list.append(format_parameter(param_name, param_required))\n\n return arg_list + opt_list","def get_paramnames_list(self):\n # TODO include syselem?\n\n query = \"SELECT NAME FROM %s\" % self.__schema\n with self.__connection.cursor() as cursor:\n cursor.execute(query)\n result = cursor.fetchall()\n return [val['NAME'] for val in result]","def parameters(self):\n return self.pars","def _GetParameters(\n self,\n required_path_params: Iterable[FieldDescriptor],\n optional_path_params: Iterable[FieldDescriptor],\n query_params: Iterable[FieldDescriptor],\n ) -> List[Dict[str, Union[str, bool, SchemaReference, ArraySchema,\n DescribedSchema]]]:\n parameters = []\n\n req_path_params_set = set(required_path_params)\n opt_path_params_set = set(optional_path_params)\n query_params_set = set(query_params)\n for field_d in req_path_params_set | opt_path_params_set | query_params_set:\n parameter_obj = {\"name\": casing.SnakeToCamel(field_d.name)}\n if field_d in req_path_params_set:\n parameter_obj[\"in\"] = \"path\"\n parameter_obj[\"required\"] = True\n elif field_d in opt_path_params_set:\n parameter_obj[\"in\"] = \"path\"\n else:\n parameter_obj[\"in\"] = \"query\"\n\n parameter_obj[\"schema\"] = self._GetDescribedSchema(field_d)\n\n parameters.append(parameter_obj)\n\n return parameters","def parameters(self):\n return {\"W\": self.W,\n \"T\": self.T,\n \"P\": self.P,\n \"Wo\": self.Wo,\n \"To\": self.To,\n \"Po\": self.Po}","def params(self):\n return self._pars","def get_params(self, pnames=None):\n l = []\n if pnames is None:\n pnames = self._params.keys()\n for pname in pnames:\n p = self._params[pname]\n if isinstance(p, Parameter):\n l.append(p)\n return l","def _fc_out_parameters(self) -> Tuple[str, List[str]]:\n out_pars = self.ret_type.fc_ret_type()\n if len(out_pars) == 1:\n return (out_pars[0][0], [])\n\n out_par_strl = list() # type: List[str]\n for type_name, postfix in out_pars:\n out_par_strl.append('{} {}'.format(\n type_name, self.ret_type.name + postfix))\n return ('void', out_par_strl)","def parameters(self):\n return [term.parameter for term in self.terms]","def parameter_tuple_maker(parameter_code, code_list, i):\n\n return (parameter_code, code_list[i])","def get_ext_param_names(self):\n num_param = core.xc_func_info_get_n_ext_params(self.xc_func_info)\n\n ret = []\n for p in range(num_param):\n tmp = core.xc_func_info_get_ext_params_name(self.xc_func_info, p)\n ret.append(tmp.decode(\"UTF-8\"))\n\n return ret","def _getTypeCodes(self, callinfo):\r\n prefix = None\r\n self._resetPrefixDict()\r\n if callinfo.use == 'encoded':\r\n prefix = self._getPrefix(callinfo.namespace)\r\n try:\r\n requestTC = self._getTypeCode(parameters=callinfo.getInParameters(), literal=(callinfo.use=='literal'))\r\n except EvaluateException, ex:\r\n print \"DEBUG: Request Failed to generate --\", ex\r\n requestTC = None\r\n\r\n self._resetPrefixDict()\r\n try:\r\n replyTC = self._getTypeCode(parameters=callinfo.getOutParameters(), literal=(callinfo.use=='literal'))\r\n except EvaluateException, ex:\r\n print \"DEBUG: Response Failed to generate --\", ex\r\n replyTC = None\r\n \r\n request = response = None\r\n if callinfo.style == 'rpc':\r\n if requestTC: request = TC.Struct(pyclass=None, ofwhat=requestTC, pname=callinfo.methodName)\r\n if replyTC: response = TC.Struct(pyclass=None, ofwhat=replyTC, pname='%sResponse' %callinfo.methodName)\r\n else:\r\n if requestTC: request = requestTC[0]\r\n if replyTC: response = replyTC[0]\r\n\r\n #THIS IS FOR RPC/ENCODED, DOC/ENCODED Wrapper\r\n if request and prefix and callinfo.use == 'encoded':\r\n request.oname = '%(prefix)s:%(name)s xmlns:%(prefix)s=\"%(namespaceURI)s\"' \\\r\n %{'prefix':prefix, 'name':request.oname, 'namespaceURI':callinfo.namespace}\r\n\r\n return request, response","def _parse_parameters(self, parameter_protos):\n logger.debug(\"Start to parse parameters from proto.\")\n for parameter in parameter_protos:\n if not parameter.name:\n logger.warning(\"Finding a parameter with an empty name will not save it.\")\n continue\n check_invalid_character(parameter.name)\n node = Node(name=parameter.name, node_id=parameter.name)\n node.type = NodeTypeEnum.PARAMETER.value\n node.output_shape = self._get_shape_by_parse_type_proto(parameter.type)\n node.output_nums = len(node.output_shape)\n node.output_data_type = self._get_data_type_by_parse_type_proto(parameter.type, node)\n attr = dict(\n type=self._get_data_type_by_parse_type_proto(parameter.type, node),\n shape=str(self._get_shape_by_parse_type_proto(parameter.type))\n )\n node.add_attr(attr)\n\n self._cache_node(node)\n logger.debug(\"Foreach graph proto parameters, node id: %s, node name: %s, \"\n \"node def name: %s\", node.node_id, node.name, parameter.name)","def compile_ids(parameters):\n return tuple(p.keys()[0] for p in parameters[1:])","def get_parameters(self, separate_):\n if separate_:\n return self.F, self.J, self.prox\n else :\n return self.Fone, self.Jone, self.prox","def parameter_list(self):\n return [\n [encut, kpoint_mesh]\n for encut, kpoint_mesh in zip(\n self._job.iteration_frame.ENCUT, self._job.iteration_frame.KPOINT_MESH\n )\n ]","def _formal_params(self, doclet):\n name, paren, params = self.arguments[0].partition('(')\n return ('(%s' % params) if params else '(%s)' % ', '.join(doclet['meta']['code']['paramnames'])","def get_str_param_names(self):\n # Exclude self.api and self.names from the command string\n return self.get_attribute_names(FormattedParameter)","def get_params(self):\n return []","def get_params_as_list(self):\n\n\t\tparams = [self.shape_slope, self.z_thick, self.thick, self.length]\n\t\treturn params","def parse_params(txt):\n res = list()\n # First, slipt with stuff looking like \\TYPE:\n splitted = re.split(r'\\s*\\\\(\\w+)\\s*:', txt)\n # We now have a list looking like:\n # ['', 'flag', '....', 'param', '...']\n i = 1\n while i < len(splitted) - 1:\n type = splitted[i]\n rest = splitted[i+1]\n if type == \"argn\":\n name = \"remaining args\"\n desc = rest\n else:\n # first word is the name, the rest is the description:\n match = re.match(r'\\s*(\\w+)\\s*(.*)', rest, re.DOTALL)\n if not match:\n print(\"warning, failed to parse parameters\")\n print(\"near\", rest)\n break\n (name, desc) = match.groups()\n desc = clean_indent(desc)\n res.append((type, name, desc))\n i += 2\n return res","def methodSignature(self, req, method):\n p = self.get_method(method)\n return [','.join([RPC_TYPES[x] for x in sig]) for sig in p.xmlrpc_signatures()]","def packParameters(params):\r\n buf = bytes(\"\")\r\n\r\n for param in params:\r\n if type(param) == memoryview:\r\n buf += bytes(param.tobytes())\r\n\r\n elif issubclass(type(param), CIDType):\r\n buf += bytes(param.pack().tobytes())\r\n\r\n else:\r\n buf += bytes(param)\r\n\r\n return buf","def param_json(self) -> Optional[List[Dict]]:\n # Handle empty dict and None value\n if not self.param:\n return []\n return [\n {\n \"prop\": k,\n \"direct\": \"IN\",\n \"type\": \"VARCHAR\",\n \"value\": v,\n }\n for k, v in self.param.items()\n ]","def create_parameter_list(path_params):\n param_list = []\n for param in path_params:\n parameter = {}\n parameter['in'] = 'path'\n parameter['name'] = str(param)\n parameter['description'] = 'ID of ' + str(param)[:-2]\n parameter['required'] = True\n parameter['type'] = 'string'\n param_list.append(parameter)\n return param_list","def parameters(self):\n return self.pkt.payload[2:]","def get_params_list():\n return common.QOL_PARAMS","def values(self):\n return {n: getattr(self, n) for n in self._hparam_types.keys()}","def getmethparlist(ob):\n defText = callText = \"\"\n # bit of a hack for methods - turn it into a function\n # but we drop the \"self\" param.\n # Try and build one for Python defined functions\n args, varargs, varkw = inspect.getargs(ob.__code__)\n items2 = args[1:]\n realArgs = args[1:]\n defaults = ob.__defaults__ or []\n defaults = [\"=%r\" % (value,) for value in defaults]\n defaults = [\"\"] * (len(realArgs)-len(defaults)) + defaults\n items1 = [arg + dflt for arg, dflt in zip(realArgs, defaults)]\n if varargs is not None:\n items1.append(\"*\" + varargs)\n items2.append(\"*\" + varargs)\n if varkw is not None:\n items1.append(\"**\" + varkw)\n items2.append(\"**\" + varkw)\n defText = \", \".join(items1)\n defText = \"(%s)\" % defText\n callText = \", \".join(items2)\n callText = \"(%s)\" % callText\n return defText, callText","def getmethparlist(ob):\n defText = callText = \"\"\n # bit of a hack for methods - turn it into a function\n # but we drop the \"self\" param.\n # Try and build one for Python defined functions\n args, varargs, varkw = inspect.getargs(ob.__code__)\n items2 = args[1:]\n realArgs = args[1:]\n defaults = ob.__defaults__ or []\n defaults = [\"=%r\" % (value,) for value in defaults]\n defaults = [\"\"] * (len(realArgs)-len(defaults)) + defaults\n items1 = [arg + dflt for arg, dflt in zip(realArgs, defaults)]\n if varargs is not None:\n items1.append(\"*\" + varargs)\n items2.append(\"*\" + varargs)\n if varkw is not None:\n items1.append(\"**\" + varkw)\n items2.append(\"**\" + varkw)\n defText = \", \".join(items1)\n defText = \"(%s)\" % defText\n callText = \", \".join(items2)\n callText = \"(%s)\" % callText\n return defText, callText","def parameters(self):\n return [i.parameter for i in self.joints.values()]","def methodSignature(self, name):\r\n methods = self._listMethods()\r\n for method in methods:\r\n if method == name:\r\n rtype = None\r\n ptypes = []\r\n parsed = gettags(methods[method])\r\n for thing in parsed:\r\n if thing[1] == 'return': # tag name\r\n rtype = thing[2] # datatype\r\n elif thing[1] == 'param': # tag name\r\n ptypes.append(thing[2]) # datatype\r\n if rtype is None:\r\n raise RPCError(Faults.SIGNATURE_UNSUPPORTED)\r\n return [rtype] + ptypes\r\n raise RPCError(Faults.SIGNATURE_UNSUPPORTED)","def parameters(self):\n return self._params","def return_parameter_names():\n return list(titles), list(labels)","def parameters(self):\n raise NotImplementedError('Abstract method \"parameters\" must be '\n 'specialised!')"],"string":"[\n \"def parameterTypes(self, p_int): # real signature unknown; restored from __doc__\\n return []\",\n \"def getParamsType(self):\\n\\t\\treturn [\\\"int\\\", \\\"int\\\"]\",\n \"def parameterNames(self, p_int): # real signature unknown; restored from __doc__\\n return []\",\n \"def _fi_in_parameters(self) -> List[Tuple[str, str]]:\\n result = list() # type: List[Tuple[str, str]]\\n for param in self.params:\\n type_list = param.fi_type()\\n for type_name, postfix in type_list:\\n result.append((type_name, param.name + postfix))\\n return result\",\n \"def _f_in_parameters(self) -> List[Tuple[str, str]]:\\n result = list() # type: List[Tuple[str, str]]\\n for param in self.params:\\n type_list = param.f_type()\\n for type_name, postfix in type_list:\\n result.append((type_name, param.name + postfix))\\n return result\",\n \"def parameter_names(self) -> List[str]:\",\n \"def _fc_in_parameters(self) -> List[str]:\\n result = list() # type: List[str]\\n\\n for param in self.params:\\n type_list = param.fc_type()\\n for type_name, postfix in type_list:\\n result.append('{} {}'.format(type_name, param.name + postfix))\\n\\n return result\",\n \"def build_parameters(self) -> List[str]:\\n param_bits = []\\n for name in self.parameters:\\n param_bits.extend(self.build_parameter_by_name(name) or [])\\n return param_bits\",\n \"def generate_parameter_map(rpc_blocks, full_signature, param_values):\\n parameter_map = []\\n list_object_pattern = re.compile(\\n r\\\"(java\\\\.util\\\\.(?:[A-Za-z]+)?List(?:[0-9/]+)?)<([a-zA-Z0-9./]+)[<>]?(?:(.*[^>]))?>\\\"\\n )\\n\\n # Append type index for each parameter value\\n for i, param in enumerate(param_values):\\n param_type = full_signature[i]\\n\\n # If parameter is of type list, append index of list type\\n if re.match(list_object_pattern, param_type):\\n list_type = re.findall(list_object_pattern, param_type)[0][0]\\n parameter_map.append(str(rpc_blocks.index(list_type) - 2))\\n\\n # If not of type list, appeand index of simple type\\n else:\\n parameter_map.append(str(rpc_blocks.index(full_signature[i]) - 2))\\n\\n # For each indexed parameter append type and value indicies\\n for i, param in enumerate(param_values):\\n param_type = full_signature[i]\\n\\n # If parameter is a string object, append value index\\n if param_type.startswith(COMPLEX_TYPES[\\\"STRING\\\"]):\\n parameter_map.append(str(rpc_blocks.index(param) - 2))\\n\\n # Else if the parameter is simple type, append value\\n elif param_type in SIMPLE_TYPES.keys():\\n parameter_map.append(str(param))\\n\\n # Else if the parameter is a java list object, append type index and length\\n elif re.match(list_object_pattern, param_type):\\n list_length = 1\\n list_type = list(filter(None, re.findall(list_object_pattern, param_type)[0]))\\n\\n parameter_map.append(\\n str(rpc_blocks.index(list_type[0] if len(list_type) < 3 else list_type[1]) - 2)\\n )\\n parameter_map.append(str(list_length))\\n\\n # For each element of the list, append type and value indicies\\n for _ in range(list_length):\\n parameter_map.append(\\n str(rpc_blocks.index(list_type[1] if len(list_type) < 3 else list_type[2]) - 2)\\n )\\n parameter_map.append(str(rpc_blocks.index(param) - 2))\\n\\n # If parameter is a so far unhandled complex type, append runtime index and value\\n elif any(\\n param_type.startswith(val)\\n for val in COMPLEX_TYPES.values()\\n ):\\n parameter_map.append(str(rpc_blocks.index(param_type) - 2))\\n parameter_map.append(str(param))\\n\\n # If parameter is unknown, append runtime index and value index\\n else:\\n parameter_map.append(str(rpc_blocks.index(param_type) - 2))\\n parameter_map.append(str(rpc_blocks.index(param) - 2))\\n\\n return parameter_map\",\n \"def getParameterList(self):\\n inputList = []\\n for name, n in zip(self._names, self._inputs):\\n inputList += ['%s.x%d' % (name, i) for i in range(n)]\\n return inputList\",\n \"def params(self):\\n params = []\\n\\n for item in self._definition.get('params', []):\\n params.append(Parameter(**item))\\n\\n return params\",\n \"def _get_parameters(self):\\n return (self.SYMBOL, self.parameterArray())\",\n \"def get_method_parameter_values(code, line, full_sig):\\n param_list = []\\n offset = int((get_offset(code, line, \\\"catch(\\\") - 3))\\n line += (1 + int(offset / 2))\\n\\n for i in range(int(offset / 2)):\\n param_pattern = re.compile(rf\\\", ?(?:'' ?\\\\+ ?)?(?:{R_VAR}\\\\(?.*, ?)?(.*[^\\\\)])\\\\)\\\\)?;\\\")\\n nested_boolean_pattern = re.compile(rf\\\".*\\\\?(('?{R_VAR}'?):('?{R_VAR}'?))\\\")\\n param = re.findall(param_pattern, code[line])[0].replace(\\\"'\\\", \\\"\\\")\\n\\n # if parameter is boolean, append 0\\n if (\\n nested_boolean_pattern.search(code[line])\\n or full_sig[i].startswith(COMPLEX_TYPES[\\\"BOOLEAN\\\"])\\n ):\\n param_list.append(\\\"§0§\\\")\\n\\n # if parameter is numeric, append directly\\n elif is_number(param) or full_sig[i].startswith(\\\"I\\\"):\\n param_list.append(f\\\"§{param if is_number(param) else randint(0,99)}§\\\")\\n\\n # else, treat as tring and append with previx\\n else:\\n param = param.replace(\\\" \\\", \\\"_\\\").replace(\\\"|\\\", \\\"\\\\\\\\!\\\").replace(\\\"\\\\\\\\\\\", \\\"\\\\\\\\\\\\\\\\\\\")\\n param_list.append(f\\\"§param_{param}§\\\")\\n line += 1\\n\\n return param_list\",\n \"def parameters_list(self):\\n return [getattr(self.parameters, p) for p in self.parameters_names()]\",\n \"def Params(self):\\n params = list()\\n if self.currtok[1].name in {\\\"INT\\\", \\\"FLOAT\\\", \\\"BOOLEAN\\\"}:\\n type = self.Type()\\n self.ids[self.currtok[0]] = type\\n id = self.primary()\\n par = Param(type, id)\\n params.append(par)\\n while self.currtok[1].name in {\\\"COMMA\\\"}:\\n self.currtok = next(self.tg)\\n type = self.Type()\\n self.ids[self.currtok[0]] = type\\n id = self.primary()\\n par = Param(type, id)\\n params.append(par)\\n return Params(params)\",\n \"def params(self) -> Tuple[Parameter, ...]:\\n raise NotImplementedError()\",\n \"def classifyParameters(self):\\n\\n arguments = []\\n options = []\\n outputs = []\\n for parameter in self.parameters():\\n if parameter.channel == 'output' and not (\\n parameter.isExternalType() or parameter.typ == 'file'):\\n outputs.append(parameter)\\n elif parameter.index is not None:\\n arguments.append(parameter)\\n if parameter.flag is not None or parameter.longflag is not None:\\n logger.warning(\\\"Parameter %s has both index=%d and flag set.\\\" % (\\n parameter.identifier(), parameter.index))\\n else:\\n options.append(parameter)\\n arguments.sort(key = lambda parameter: parameter.index)\\n return (arguments, options, outputs)\",\n \"def get_parameters(self, doc, type_table):\\n scraper = TypeScraper(type_table=type_table)\\n r = docscrape.NumpyDocString(doc)\\n paras = {}\\n for p in r['Parameters']:\\n\\n para_str = str(p.type)\\n para_type = scraper.scrap(para_str)\\n if self.is_valid_para(para_type, type_table):\\n paras[p.name] = scraper.scrap(para_str)\\n else:\\n continue\\n return paras\",\n \"def parameter(self):\\n res = dict()\\n for x in self._desc.fields:\\n if x.type == FieldDescriptor.TYPE_MESSAGE:\\n parameter = ParameterGroup(x)\\n elif x.type == FieldDescriptor.TYPE_ENUM:\\n parameter = ParameterEnum(x)\\n else:\\n parameter = ParameterPrimitive(x)\\n\\n res[x.name] = parameter\\n\\n return res\",\n \"def __parameters__(self) -> tuple[TypeVar, ...]:\\n return super().__getattribute__(\\\"_parameters\\\")\",\n \"def compile_parameter_list(self):\\r\\n if self.__tokenizer.token_type() != TYPES_DIC[\\\"SYMBOL\\\"]:\\r\\n type = self.__get_type()\\r\\n self.__advance()\\r\\n name = self.__tokenizer.identifier()\\r\\n self.__subroutine_symbols.define(name, type, \\\"argument\\\")\\r\\n self.__advance()\\r\\n while self.__tokenizer.symbol() != ')':\\r\\n self.__advance()\\r\\n type = self.__get_type()\\r\\n self.__advance()\\r\\n name = self.__tokenizer.identifier()\\r\\n self.__subroutine_symbols.define(name, type, \\\"argument\\\")\\r\\n self.__advance()\",\n \"def parameters(self):\\n return []\",\n \"def _get_parameters(self) -> list:\\n return self.parameters\",\n \"def parameter_names(self) -> list:\\n parameters = []\\n parameters.extend(self.properties.parameter_names)\\n return parameters\",\n \"def get_parameters(self):\\n result = self.generate_parameters()\\n id, vector = result\\n if not vector:\\n return id, vector\\n\\n params = {}\\n for idx in range(len(self.param_names)):\\n name = self.param_names[idx]\\n settings = self.param_settings[idx]\\n value = vector[idx]\\n if settings['type'] == \\\"int\\\":\\n value = int(round(value))\\n elif settings['type'] == \\\"float\\\":\\n value = float(value)\\n params[name] = value\\n return id, params\",\n \"def parameters(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Statement.Declaration]:\",\n \"def getTypeCode(self):\\n return _libsbml.Parameter_getTypeCode(self)\",\n \"def get_ext_param_descriptions(self):\\n num_param = core.xc_func_info_get_n_ext_params(self.xc_func_info)\\n\\n ret = []\\n for p in range(num_param):\\n tmp = core.xc_func_info_get_ext_params_description(self.xc_func_info, p)\\n ret.append(tmp.decode(\\\"UTF-8\\\"))\\n\\n return ret\",\n \"def param(self):\\r\\n\\r\\n return []\",\n \"def parameters(self) -> List[Parameter]:\\n return self._parameters\",\n \"def _declare_parameters(self):\\n def to_modelica(arg):\\n \\\"\\\"\\\" Convert to Modelica array.\\n \\\"\\\"\\\"\\n # Check for strings and booleans\\n if isinstance(arg, str):\\n return '\\\\\\\\\\\"' + arg + '\\\\\\\\\\\"'\\n elif isinstance(arg, bool):\\n if arg is True:\\n return 'true'\\n else:\\n return 'false'\\n try:\\n return '{' + \\\", \\\".join(to_modelica(x) for x in arg) + '}'\\n except TypeError:\\n return repr(arg)\\n dec = list()\\n\\n for k, v in list(self._parameters_.items()):\\n # Dymola requires vectors of parameters to be set in the format\\n # p = {1, 2, 3} rather than in the format of python arrays, which\\n # is p = [1, 2, 3].\\n # Hence, we convert the value of the parameter if required.\\n s = to_modelica(v)\\n dec.append('{param}={value}'.format(param=k, value=s))\\n\\n return dec\",\n \"def get_parameter_descriptions(parameters):\\n\\n lines = []\\n opt_lines = []\\n for param in parameters:\\n param_name = check_param(flatten_param(param['name']))\\n if param['required']:\\n required = 'required'\\n lines.append(':param {0}: ({1}) {2}'.format(param_name, required,\\n param['description']))\\n lines.append(':type {0}: {1}'.format(param_name, param['type']))\\n else:\\n required = 'optional'\\n opt_lines.append(':param {0}: ({1}) {2}'.format(param_name,\\n required, param['description']))\\n opt_lines.append(':type {0}: {1} or None'.format(param_name,\\n param['type']))\\n\\n return lines + opt_lines\",\n \"def params(self):\\n return tuple(self._params)\",\n \"def param(self):\\n return []\",\n \"def param(self):\\n return []\",\n \"def parameter_values(self) -> List[Tuple[str, Any]]:\\n pvs = [(param, getattr(self, variable))\\n for variable, param in self.variable_name_to_query_param.items()]\\n return [(p, v) for p, v in pvs if v is not None]\",\n \"def param_strs(self):\\n name_len = max(len(p.name) for p in self)\\n value_len = max(len(p.value_str) for p in self.params.values())\\n units_len = max(len(p.units) for p in self.params.values())\\n return [(p.name.ljust(name_len), p.value_str.ljust(value_len),\\n p.units.ljust(units_len), p.__doc__)\\n for p in self.params.values() if p]\",\n \"def parameters(self):\\n params = []\\n for layer in (self.conv1, self.conv2, self.conv3, self.conv4, self.dense1, self.dense2):\\n params += list(layer.parameters)\\n return params\",\n \"def parameters(self):\\n return [p for _, a in vars(self).items() for p in self._params(a)]\",\n \"def decode(self):\\n # make a copy since in case of XML it could be necessary to modify\\n # the raw_params - filter out elements different than params\\n raw_params = deepcopy(self.raw_params)\\n params_def = self.params_def\\n # ignore other tags than \\\"param\\\" and \\\"paramRepeat\\\"\\n # e.g. sequencer may create tags like \\\"hookPlace\\\"\\n if isinstance(raw_params, etree._Element):\\n for raw_param in raw_params:\\n if not raw_param.tag in (\\\"param\\\", \\\"paramrepeat\\\"):\\n raw_params.remove(raw_param)\\n\\n params = []\\n # check if too many parameters were passed\\n len_params_def = len(params_def)\\n if len(raw_params) > len_params_def:\\n msg = (\\\"%r are supernumerary with respect to definition\\\" %\\n raw_params[len_params_def:])\\n raise SupernumeraryParam, msg\\n # iterate over definition since missing values may just mean using\\n # the default values\\n for i, param_def in enumerate(params_def):\\n try:\\n raw_param = raw_params[i]\\n except IndexError:\\n raw_param = None\\n obj = self.decodeNormal(raw_param, param_def)\\n params.append(obj)\\n self.params = params\\n return self.params\",\n \"def typeParameters():\\n\\t\\td = AdaptiveBatAlgorithm.typeParameters()\\n\\t\\td.pop('A', None), d.pop('r', None)\\n\\t\\td.update({\\n\\t\\t\\t'A_l': lambda x: isinstance(x, (float, int)) and x >= 0,\\n\\t\\t\\t'A_u': lambda x: isinstance(x, (float, int)) and x >= 0,\\n\\t\\t\\t'r_l': lambda x: isinstance(x, (float, int)) and x >= 0,\\n\\t\\t\\t'r_u': lambda x: isinstance(x, (float, int)) and x >= 0,\\n\\t\\t\\t'tao_1': lambda x: isinstance(x, (float, int)) and 0 <= x <= 1,\\n\\t\\t\\t'tao_2': lambda x: isinstance(x, (float, int)) and 0 <= x <= 1\\n\\t\\t})\\n\\t\\treturn d\",\n \"def getListOfParameters(self):\\n return self.model.getListOfParameters()\",\n \"def param(self):\\r\\n return []\",\n \"def parameters_names(cls):\\n return cls._Parameters._fields\",\n \"def getParameters(self): #$NON-NLS-1$\\r\",\n \"def identifiers(self):\\n identifiers = []\\n\\n for item in self._definition.get('identifiers', []):\\n identifiers.append(Parameter(**item))\\n\\n return identifiers\",\n \"def get_params(node):\\n if node.type == 'parameter':\\n return [(self.descend(node.args[0]), types.translation[self.descend(node.args[1])])]\\n else:\\n l = []\\n for p in node.args:\\n l.extend(get_params(p))\\n return l\",\n \"def get_parameters_list(self):\\n return self.description[\\\"config\\\"][\\\"values\\\"].keys()\",\n \"def get_parameter_names(self):\\n parNames = []\\n # for par in self.variables: # TODO: LIKELY A BUG! DOES THE SAME AS get_variable_names()\\n for par in self.parameters: # TRYING TO SOLVE THE ISSUE\\n # EstimationVariable\\n parNames.append(par.name)\\n return parNames\",\n \"def get_design_parameters(self):\\n return self.__get_one_type_params(DesignParameter)\",\n \"def generate_parameters(self):\\n id = len(self.param_values)\\n\\n vector = []\\n \\n for idx in range(len(self.param_names)):\\n name = self.param_names[idx]\\n value = None\\n settings = self.param_settings[idx]\\n new_value = self.get_next_parameter(name, value, settings, id=id)\\n vector.append(self.clamp(new_value, settings['min'], settings['max']))\\n\\n self.param_values.append(vector)\\n self.result.append(None)\\n return id, vector\",\n \"def parameters(self):\\n return {\\\"P\\\": self.P,\\n \\\"T\\\": self.T}\",\n \"def get_param_names(self):\\n return list(self.params.keys())\",\n \"def params(self) -> List[ParamSpec]:\\n return self._params\",\n \"def compile_parameter_list(self):\\r\\n var_type = None\\r\\n while True:\\r\\n self.tokenizer.advance()\\r\\n tok_type = self.tokenizer.token_type()\\r\\n if tok_type == JackTokenizer.KEYWORD_T:\\r\\n var_type = self.tokenizer.key_word()\\r\\n elif tok_type == JackTokenizer.IDENTIFIER_T:\\r\\n if not var_type:\\r\\n var_type = self.tokenizer.identifier()\\r\\n else:\\r\\n var_name = self.tokenizer.identifier()\\r\\n self.symbol_table.define(var_name, var_type, SymbolTable.ARG)\\r\\n var_type = None\\r\\n else:\\r\\n sym = self.tokenizer.symbol()\\r\\n if sym == \\\")\\\":\\r\\n break\",\n \"def getTypeCode(self):\\n return _libsbml.LocalParameter_getTypeCode(self)\",\n \"def get_parameter_declarations(self, root):\\n param_declare_group = etree.SubElement(root, \\\"ParameterDeclarations\\\")\\n if QgsProject.instance().mapLayersByName(\\\"Parameter Declarations\\\"):\\n param_layer = QgsProject.instance().mapLayersByName(\\\"Parameter Declarations\\\")[0]\\n for feature in param_layer.getFeatures():\\n param_name = feature[\\\"Parameter Name\\\"]\\n param_type = feature[\\\"Type\\\"]\\n param_value = feature[\\\"Value\\\"]\\n\\n param = etree.SubElement(param_declare_group, \\\"ParameterDeclaration\\\")\\n param.set(\\\"name\\\", param_name)\\n param.set(\\\"type\\\", param_type)\\n param.set(\\\"value\\\", param_value)\",\n \"def compile_params(parameters):\\n return tuple(p.values()[0] for p in parameters[1:])\",\n \"def get_paginator_parameters(self, paginator):\\n fields = []\\n if hasattr(paginator, 'get_schema_fields'):\\n fields = paginator.get_schema_fields(self.view)\\n\\n return [self.coreapi_field_to_parameter(field) for field in fields]\",\n \"def get_field_parameters(self, in_parms):\\n if len(in_parms) == 0: # Check if there are params\\n return None # If that's the case, return None\\n\\n values = [] # Empty values\\n is_msg = False # Check if the param is a message\\n for parm in in_parms: # Loop over params\\n if parm.type == \\\"Field\\\": # If it is a message\\n is_msg = True # Set is_message to true\\n continue # Go to top of loop\\n _type = eval(parm.type) # create a type object\\n value = _type(parm.value) # Create the value, and cast it to the type\\n values.append(value) # Add that into the parameters\\n if is_msg is True: # check if is a message\\n return in_parms # Return input params\\n elif len(values) == 1: # If there is only one element\\n return values[-1] # Return just that element\\n else: # Otherwise\\n return values # Return the params\",\n \"def split_params(self, params):\\n\\t\\tindex = 0\\n\\t\\tacc = ''\\n\\t\\tret = [] #return value (is ret a bad name?)\\n\\t\\twhile index < len(params):\\n\\t\\t\\tif params[index] == ',': #End of a parameter\\n\\t\\t\\t\\tret.append(acc)\\n\\t\\t\\t\\tacc = ''\\n\\t\\t\\telif params[index] == '(': #start of a type that is a function\\n\\t\\t\\t\\tend = params.match_paren(index)\\n\\t\\t\\t\\twhile index <= end: #so the commas in the function type\\n\\t\\t\\t\\t\\t# are disregarded\\n\\t\\t\\t\\t\\tacc += params[index]\\n\\t\\t\\t\\t\\tindex += 1\\n\\t\\t\\t\\tcontinue #so index doesn't get incremented again\\n\\t\\t\\telse:\\n\\t\\t\\t\\tacc += params[index]\\n\\t\\t\\tindex += 1\\n\\n\\t\\tif acc: #if they ended the list with a comma then acc would be ''\\n\\t\\t\\tret.append(acc) #parameters not ended with a comma,\\n\\t\\t\\t# acc last the last param\\n\\n\\t\\treturn ret\",\n \"def _fi_out_parameters(self) -> Tuple[str, List[Tuple[str, str]]]:\\n out_pars = self.ret_type.fi_ret_type()\\n if len(out_pars) == 1:\\n return (out_pars[0][0], [])\\n\\n out_par_list = list() # type: List[Tuple[str, str]]\\n for par_type, par_name in out_pars:\\n out_par_list.append((par_type, 'ret_val' + par_name))\\n\\n return ('', out_par_list)\",\n \"def extract_method_signature(code, line):\\n line += 5\\n method_signature = []\\n offset = get_offset(code, line, \\\"catch(\\\")\\n param_pattern = re.compile(rf\\\"{R_VAR}\\\\(.*, ?.*, ?(.*)\\\\)\\\\);\\\")\\n\\n for _ in range(int((offset - 2) / 2)):\\n parameter = parse_parameter(code, re.findall(param_pattern, code[line])[0])\\n\\n # If List type found, assume ArrayList implementation of Strings\\n if parameter.startswith(COMPLEX_TYPES[\\\"LIST\\\"]):\\n parameter += f\\\"<{COMPLEX_TYPES['ARRAY']}/4159755760\\\"\\n parameter += f\\\"<{COMPLEX_TYPES['STRING']}/2004016611>>\\\"\\n\\n # If specific List implementation found, assume it is of Strings\\n elif re.match(r\\\"java\\\\.util\\\\.[A-Za-z]+List/.*\\\", parameter):\\n parameter += f\\\"<{COMPLEX_TYPES['STRING']}/2004016611>\\\"\\n\\n method_signature.append(parameter)\\n\\n line += 1\\n\\n return method_signature\",\n \"def getListOfParameters(self, *args):\\n return _libsbml.Model_getListOfParameters(self, *args)\",\n \"def params(self):\\n if isinstance(self.request, list):\\n return unmunchify(self.request)\\n (params, _) = xmlrpc.loads(self.request)\\n return params\",\n \"def get_parameters(parameters):\\n\\n arg_list = []\\n opt_list = []\\n for param in parameters:\\n param_name = param['name']\\n param_required = param['required']\\n if param_required:\\n arg_list.append(format_parameter(param_name, param_required))\\n else:\\n opt_list.append(format_parameter(param_name, param_required))\\n\\n return arg_list + opt_list\",\n \"def get_paramnames_list(self):\\n # TODO include syselem?\\n\\n query = \\\"SELECT NAME FROM %s\\\" % self.__schema\\n with self.__connection.cursor() as cursor:\\n cursor.execute(query)\\n result = cursor.fetchall()\\n return [val['NAME'] for val in result]\",\n \"def parameters(self):\\n return self.pars\",\n \"def _GetParameters(\\n self,\\n required_path_params: Iterable[FieldDescriptor],\\n optional_path_params: Iterable[FieldDescriptor],\\n query_params: Iterable[FieldDescriptor],\\n ) -> List[Dict[str, Union[str, bool, SchemaReference, ArraySchema,\\n DescribedSchema]]]:\\n parameters = []\\n\\n req_path_params_set = set(required_path_params)\\n opt_path_params_set = set(optional_path_params)\\n query_params_set = set(query_params)\\n for field_d in req_path_params_set | opt_path_params_set | query_params_set:\\n parameter_obj = {\\\"name\\\": casing.SnakeToCamel(field_d.name)}\\n if field_d in req_path_params_set:\\n parameter_obj[\\\"in\\\"] = \\\"path\\\"\\n parameter_obj[\\\"required\\\"] = True\\n elif field_d in opt_path_params_set:\\n parameter_obj[\\\"in\\\"] = \\\"path\\\"\\n else:\\n parameter_obj[\\\"in\\\"] = \\\"query\\\"\\n\\n parameter_obj[\\\"schema\\\"] = self._GetDescribedSchema(field_d)\\n\\n parameters.append(parameter_obj)\\n\\n return parameters\",\n \"def parameters(self):\\n return {\\\"W\\\": self.W,\\n \\\"T\\\": self.T,\\n \\\"P\\\": self.P,\\n \\\"Wo\\\": self.Wo,\\n \\\"To\\\": self.To,\\n \\\"Po\\\": self.Po}\",\n \"def params(self):\\n return self._pars\",\n \"def get_params(self, pnames=None):\\n l = []\\n if pnames is None:\\n pnames = self._params.keys()\\n for pname in pnames:\\n p = self._params[pname]\\n if isinstance(p, Parameter):\\n l.append(p)\\n return l\",\n \"def _fc_out_parameters(self) -> Tuple[str, List[str]]:\\n out_pars = self.ret_type.fc_ret_type()\\n if len(out_pars) == 1:\\n return (out_pars[0][0], [])\\n\\n out_par_strl = list() # type: List[str]\\n for type_name, postfix in out_pars:\\n out_par_strl.append('{} {}'.format(\\n type_name, self.ret_type.name + postfix))\\n return ('void', out_par_strl)\",\n \"def parameters(self):\\n return [term.parameter for term in self.terms]\",\n \"def parameter_tuple_maker(parameter_code, code_list, i):\\n\\n return (parameter_code, code_list[i])\",\n \"def get_ext_param_names(self):\\n num_param = core.xc_func_info_get_n_ext_params(self.xc_func_info)\\n\\n ret = []\\n for p in range(num_param):\\n tmp = core.xc_func_info_get_ext_params_name(self.xc_func_info, p)\\n ret.append(tmp.decode(\\\"UTF-8\\\"))\\n\\n return ret\",\n \"def _getTypeCodes(self, callinfo):\\r\\n prefix = None\\r\\n self._resetPrefixDict()\\r\\n if callinfo.use == 'encoded':\\r\\n prefix = self._getPrefix(callinfo.namespace)\\r\\n try:\\r\\n requestTC = self._getTypeCode(parameters=callinfo.getInParameters(), literal=(callinfo.use=='literal'))\\r\\n except EvaluateException, ex:\\r\\n print \\\"DEBUG: Request Failed to generate --\\\", ex\\r\\n requestTC = None\\r\\n\\r\\n self._resetPrefixDict()\\r\\n try:\\r\\n replyTC = self._getTypeCode(parameters=callinfo.getOutParameters(), literal=(callinfo.use=='literal'))\\r\\n except EvaluateException, ex:\\r\\n print \\\"DEBUG: Response Failed to generate --\\\", ex\\r\\n replyTC = None\\r\\n \\r\\n request = response = None\\r\\n if callinfo.style == 'rpc':\\r\\n if requestTC: request = TC.Struct(pyclass=None, ofwhat=requestTC, pname=callinfo.methodName)\\r\\n if replyTC: response = TC.Struct(pyclass=None, ofwhat=replyTC, pname='%sResponse' %callinfo.methodName)\\r\\n else:\\r\\n if requestTC: request = requestTC[0]\\r\\n if replyTC: response = replyTC[0]\\r\\n\\r\\n #THIS IS FOR RPC/ENCODED, DOC/ENCODED Wrapper\\r\\n if request and prefix and callinfo.use == 'encoded':\\r\\n request.oname = '%(prefix)s:%(name)s xmlns:%(prefix)s=\\\"%(namespaceURI)s\\\"' \\\\\\r\\n %{'prefix':prefix, 'name':request.oname, 'namespaceURI':callinfo.namespace}\\r\\n\\r\\n return request, response\",\n \"def _parse_parameters(self, parameter_protos):\\n logger.debug(\\\"Start to parse parameters from proto.\\\")\\n for parameter in parameter_protos:\\n if not parameter.name:\\n logger.warning(\\\"Finding a parameter with an empty name will not save it.\\\")\\n continue\\n check_invalid_character(parameter.name)\\n node = Node(name=parameter.name, node_id=parameter.name)\\n node.type = NodeTypeEnum.PARAMETER.value\\n node.output_shape = self._get_shape_by_parse_type_proto(parameter.type)\\n node.output_nums = len(node.output_shape)\\n node.output_data_type = self._get_data_type_by_parse_type_proto(parameter.type, node)\\n attr = dict(\\n type=self._get_data_type_by_parse_type_proto(parameter.type, node),\\n shape=str(self._get_shape_by_parse_type_proto(parameter.type))\\n )\\n node.add_attr(attr)\\n\\n self._cache_node(node)\\n logger.debug(\\\"Foreach graph proto parameters, node id: %s, node name: %s, \\\"\\n \\\"node def name: %s\\\", node.node_id, node.name, parameter.name)\",\n \"def compile_ids(parameters):\\n return tuple(p.keys()[0] for p in parameters[1:])\",\n \"def get_parameters(self, separate_):\\n if separate_:\\n return self.F, self.J, self.prox\\n else :\\n return self.Fone, self.Jone, self.prox\",\n \"def parameter_list(self):\\n return [\\n [encut, kpoint_mesh]\\n for encut, kpoint_mesh in zip(\\n self._job.iteration_frame.ENCUT, self._job.iteration_frame.KPOINT_MESH\\n )\\n ]\",\n \"def _formal_params(self, doclet):\\n name, paren, params = self.arguments[0].partition('(')\\n return ('(%s' % params) if params else '(%s)' % ', '.join(doclet['meta']['code']['paramnames'])\",\n \"def get_str_param_names(self):\\n # Exclude self.api and self.names from the command string\\n return self.get_attribute_names(FormattedParameter)\",\n \"def get_params(self):\\n return []\",\n \"def get_params_as_list(self):\\n\\n\\t\\tparams = [self.shape_slope, self.z_thick, self.thick, self.length]\\n\\t\\treturn params\",\n \"def parse_params(txt):\\n res = list()\\n # First, slipt with stuff looking like \\\\TYPE:\\n splitted = re.split(r'\\\\s*\\\\\\\\(\\\\w+)\\\\s*:', txt)\\n # We now have a list looking like:\\n # ['', 'flag', '....', 'param', '...']\\n i = 1\\n while i < len(splitted) - 1:\\n type = splitted[i]\\n rest = splitted[i+1]\\n if type == \\\"argn\\\":\\n name = \\\"remaining args\\\"\\n desc = rest\\n else:\\n # first word is the name, the rest is the description:\\n match = re.match(r'\\\\s*(\\\\w+)\\\\s*(.*)', rest, re.DOTALL)\\n if not match:\\n print(\\\"warning, failed to parse parameters\\\")\\n print(\\\"near\\\", rest)\\n break\\n (name, desc) = match.groups()\\n desc = clean_indent(desc)\\n res.append((type, name, desc))\\n i += 2\\n return res\",\n \"def methodSignature(self, req, method):\\n p = self.get_method(method)\\n return [','.join([RPC_TYPES[x] for x in sig]) for sig in p.xmlrpc_signatures()]\",\n \"def packParameters(params):\\r\\n buf = bytes(\\\"\\\")\\r\\n\\r\\n for param in params:\\r\\n if type(param) == memoryview:\\r\\n buf += bytes(param.tobytes())\\r\\n\\r\\n elif issubclass(type(param), CIDType):\\r\\n buf += bytes(param.pack().tobytes())\\r\\n\\r\\n else:\\r\\n buf += bytes(param)\\r\\n\\r\\n return buf\",\n \"def param_json(self) -> Optional[List[Dict]]:\\n # Handle empty dict and None value\\n if not self.param:\\n return []\\n return [\\n {\\n \\\"prop\\\": k,\\n \\\"direct\\\": \\\"IN\\\",\\n \\\"type\\\": \\\"VARCHAR\\\",\\n \\\"value\\\": v,\\n }\\n for k, v in self.param.items()\\n ]\",\n \"def create_parameter_list(path_params):\\n param_list = []\\n for param in path_params:\\n parameter = {}\\n parameter['in'] = 'path'\\n parameter['name'] = str(param)\\n parameter['description'] = 'ID of ' + str(param)[:-2]\\n parameter['required'] = True\\n parameter['type'] = 'string'\\n param_list.append(parameter)\\n return param_list\",\n \"def parameters(self):\\n return self.pkt.payload[2:]\",\n \"def get_params_list():\\n return common.QOL_PARAMS\",\n \"def values(self):\\n return {n: getattr(self, n) for n in self._hparam_types.keys()}\",\n \"def getmethparlist(ob):\\n defText = callText = \\\"\\\"\\n # bit of a hack for methods - turn it into a function\\n # but we drop the \\\"self\\\" param.\\n # Try and build one for Python defined functions\\n args, varargs, varkw = inspect.getargs(ob.__code__)\\n items2 = args[1:]\\n realArgs = args[1:]\\n defaults = ob.__defaults__ or []\\n defaults = [\\\"=%r\\\" % (value,) for value in defaults]\\n defaults = [\\\"\\\"] * (len(realArgs)-len(defaults)) + defaults\\n items1 = [arg + dflt for arg, dflt in zip(realArgs, defaults)]\\n if varargs is not None:\\n items1.append(\\\"*\\\" + varargs)\\n items2.append(\\\"*\\\" + varargs)\\n if varkw is not None:\\n items1.append(\\\"**\\\" + varkw)\\n items2.append(\\\"**\\\" + varkw)\\n defText = \\\", \\\".join(items1)\\n defText = \\\"(%s)\\\" % defText\\n callText = \\\", \\\".join(items2)\\n callText = \\\"(%s)\\\" % callText\\n return defText, callText\",\n \"def getmethparlist(ob):\\n defText = callText = \\\"\\\"\\n # bit of a hack for methods - turn it into a function\\n # but we drop the \\\"self\\\" param.\\n # Try and build one for Python defined functions\\n args, varargs, varkw = inspect.getargs(ob.__code__)\\n items2 = args[1:]\\n realArgs = args[1:]\\n defaults = ob.__defaults__ or []\\n defaults = [\\\"=%r\\\" % (value,) for value in defaults]\\n defaults = [\\\"\\\"] * (len(realArgs)-len(defaults)) + defaults\\n items1 = [arg + dflt for arg, dflt in zip(realArgs, defaults)]\\n if varargs is not None:\\n items1.append(\\\"*\\\" + varargs)\\n items2.append(\\\"*\\\" + varargs)\\n if varkw is not None:\\n items1.append(\\\"**\\\" + varkw)\\n items2.append(\\\"**\\\" + varkw)\\n defText = \\\", \\\".join(items1)\\n defText = \\\"(%s)\\\" % defText\\n callText = \\\", \\\".join(items2)\\n callText = \\\"(%s)\\\" % callText\\n return defText, callText\",\n \"def parameters(self):\\n return [i.parameter for i in self.joints.values()]\",\n \"def methodSignature(self, name):\\r\\n methods = self._listMethods()\\r\\n for method in methods:\\r\\n if method == name:\\r\\n rtype = None\\r\\n ptypes = []\\r\\n parsed = gettags(methods[method])\\r\\n for thing in parsed:\\r\\n if thing[1] == 'return': # tag name\\r\\n rtype = thing[2] # datatype\\r\\n elif thing[1] == 'param': # tag name\\r\\n ptypes.append(thing[2]) # datatype\\r\\n if rtype is None:\\r\\n raise RPCError(Faults.SIGNATURE_UNSUPPORTED)\\r\\n return [rtype] + ptypes\\r\\n raise RPCError(Faults.SIGNATURE_UNSUPPORTED)\",\n \"def parameters(self):\\n return self._params\",\n \"def return_parameter_names():\\n return list(titles), list(labels)\",\n \"def parameters(self):\\n raise NotImplementedError('Abstract method \\\"parameters\\\" must be '\\n 'specialised!')\"\n]"},"negative_scores":{"kind":"list like","value":["0.6973047","0.63543373","0.6333325","0.628187","0.62337446","0.6057316","0.6028395","0.6020107","0.60162276","0.5864634","0.5859402","0.58460873","0.5785523","0.5735038","0.5657189","0.5608447","0.56071746","0.5583623","0.55738485","0.55229664","0.5505756","0.5493563","0.54874027","0.548255","0.5477482","0.5460601","0.54441035","0.5426989","0.5421317","0.54047585","0.54003024","0.53997904","0.5391674","0.53752714","0.53752714","0.5366381","0.53526354","0.5347416","0.53416455","0.53396225","0.53339463","0.53214407","0.5314998","0.5309011","0.5307162","0.5293975","0.52792567","0.5274513","0.5274282","0.5252961","0.52257025","0.5221024","0.52189946","0.5203584","0.5198364","0.51920855","0.5190797","0.5189176","0.5181118","0.5177193","0.51754963","0.5175333","0.51664984","0.51477903","0.5140619","0.51288813","0.51177627","0.5109485","0.5103466","0.5099938","0.5097136","0.50905865","0.50828034","0.50819546","0.5079473","0.50751066","0.5063971","0.5063072","0.5056461","0.50558925","0.50516826","0.5046655","0.5038978","0.5013095","0.50020343","0.50006866","0.49947912","0.49941272","0.4993597","0.49818012","0.49772528","0.4969707","0.4967129","0.49530426","0.49530426","0.4948864","0.4945405","0.49446562","0.49410713","0.49400368"],"string":"[\n \"0.6973047\",\n \"0.63543373\",\n \"0.6333325\",\n \"0.628187\",\n \"0.62337446\",\n \"0.6057316\",\n \"0.6028395\",\n \"0.6020107\",\n \"0.60162276\",\n \"0.5864634\",\n \"0.5859402\",\n \"0.58460873\",\n \"0.5785523\",\n \"0.5735038\",\n \"0.5657189\",\n \"0.5608447\",\n \"0.56071746\",\n \"0.5583623\",\n \"0.55738485\",\n \"0.55229664\",\n \"0.5505756\",\n \"0.5493563\",\n \"0.54874027\",\n \"0.548255\",\n \"0.5477482\",\n \"0.5460601\",\n \"0.54441035\",\n \"0.5426989\",\n \"0.5421317\",\n \"0.54047585\",\n \"0.54003024\",\n \"0.53997904\",\n \"0.5391674\",\n \"0.53752714\",\n \"0.53752714\",\n \"0.5366381\",\n \"0.53526354\",\n \"0.5347416\",\n \"0.53416455\",\n \"0.53396225\",\n \"0.53339463\",\n \"0.53214407\",\n \"0.5314998\",\n \"0.5309011\",\n \"0.5307162\",\n \"0.5293975\",\n \"0.52792567\",\n \"0.5274513\",\n \"0.5274282\",\n \"0.5252961\",\n \"0.52257025\",\n \"0.5221024\",\n \"0.52189946\",\n \"0.5203584\",\n \"0.5198364\",\n \"0.51920855\",\n \"0.5190797\",\n \"0.5189176\",\n \"0.5181118\",\n \"0.5177193\",\n \"0.51754963\",\n \"0.5175333\",\n \"0.51664984\",\n \"0.51477903\",\n \"0.5140619\",\n \"0.51288813\",\n \"0.51177627\",\n \"0.5109485\",\n \"0.5103466\",\n \"0.5099938\",\n \"0.5097136\",\n \"0.50905865\",\n \"0.50828034\",\n \"0.50819546\",\n \"0.5079473\",\n \"0.50751066\",\n \"0.5063971\",\n \"0.5063072\",\n \"0.5056461\",\n \"0.50558925\",\n \"0.50516826\",\n \"0.5046655\",\n \"0.5038978\",\n \"0.5013095\",\n \"0.50020343\",\n \"0.50006866\",\n \"0.49947912\",\n \"0.49941272\",\n \"0.4993597\",\n \"0.49818012\",\n \"0.49772528\",\n \"0.4969707\",\n \"0.4967129\",\n \"0.49530426\",\n \"0.49530426\",\n \"0.4948864\",\n \"0.4945405\",\n \"0.49446562\",\n \"0.49410713\",\n \"0.49400368\"\n]"},"document_score":{"kind":"string","value":"0.61186475"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":1698,"cells":{"query":{"kind":"string","value":"namespaces typecodes representing global elements with literal encoding. typeCode typecode representing an element. namespaceURI namespace literal True/False"},"document":{"kind":"string","value":"def _globalElement(self, typeCode, namespaceURI, literal):\r\n if literal:\r\n typeCode.oname = '%(prefix)s:%(name)s xmlns:%(prefix)s=\"%(namespaceURI)s\"' \\\r\n %{'prefix':self._getPrefix(namespaceURI), 'name':typeCode.oname, 'namespaceURI':namespaceURI}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def XmlTypeNamespace(self) -> str:","def is_namespace_type(self):\n raise exceptions.NotImplementedError()","def GetNamespaces(self):\n return list(self.type_namespaces_map.values())","def element_type(self) -> global___Type:","def patch_well_known_namespaces(etree_module):\n etree_module._namespace_map.update({\n \"http://www.w3.org/1999/02/22-rdf-syntax-ns#\": \"rdf\", \n \"http://purl.org/rss/1.0/\": \"rss\", \n \"http://purl.org/rss/1.0/modules/taxonomy/\": \"taxo\", \n \"http://purl.org/dc/elements/1.1/\": \"dc\", \n \"http://purl.org/rss/1.0/modules/syndication/\": \"syn\", \n \"http://www.w3.org/2003/01/geo/wgs84_pos#\": \"geo\"})","def _AppIdNamespaceKindForKey(self, key):\n last_path = key.path().element_list()[-1]\n return (datastore_types.EncodeAppIdNamespace(key.app(), key.name_space()),\n last_path.type())","def hasNamespaceURI(self, *args):\n return _libsbml.XMLToken_hasNamespaceURI(self, *args)","def GetNamespace(self, namespace_name):\n return self.type_namespaces_map.get(namespace_name, None)","def visit_Typedef(self, node):\n return str_node(node)","def test_namespaceFound(self):\n xp = XPathQuery(\"/foo[@xmlns='testns']/bar\")\n self.assertEqual(xp.matches(self.e), 1)","def namespaces(self) -> NamespacesType:\n return self.schema.namespaces","def getEnumerationTypeXmlStub (typeName): \n\tsimpleType = createSchemaElement(\"simpleType\")\n\tsimpleType.setAttribute (\"name\",typeName)\n\trestriction = createSchemaElement(\"restriction\")\n\trestriction.setAttribute (\"base\", qp(\"token\"))\n\tsimpleType.appendChild (restriction)\n\treturn simpleType","def _getTypeClass(self, namespaceURI, localName):\r\n bti = BaseTypeInterpreter()\r\n simpleTypeClass = bti.get_typeclass(localName, namespaceURI)\r\n return simpleTypeClass","def XmlTypeName(self) -> str:","def XmlNamespace(self) -> str:","def getNamespaceURI(self, *args):\n return _libsbml.XMLToken_getNamespaceURI(self, *args)","def translate_custom_types(self):\n\n\t\t# Preparing variables\n\t\ta_residue_names = self.a_atoms[\"residue_name\"]\t\t# Loads the names of residues\n\t\ta_atom_name = self.a_atoms[\"atom_name\"]\t\t# Loads the names of the atoms\n\t\ta_atom_symbol = self.a_atoms[\"element_symbol\"]\t\t# Loads the elements symbols\n\t\tl_s_custom_types = []\t\t# Contains the list of converted types\n\t\td_translate_custom = {\t\t# Conversion dictionary for custom types\n\t\t\t\"O\": \"OC\",\n\t\t\t\"H\": \"H\",\n\t\t\t\"N\": \"NAM\",\n\t\t\t\"C\": \"XOT\",\n\t\t\t\"CA\": \"XOT\",\n\t\t\t\"CB\": \"XOT\",\n\t\t\t\"OXT\": \"XOT\"\n\t\t}\n\n\t\t# STEP 1 : Converting the atom types ---------------- #\n\t\t# For each element to convert\n\t\tfor i_element in range(len(a_residue_names)):\n\n\t\t\t# If the residue is one of the main amino acids\n\t\t\tif a_residue_names[i_element] in elem_config.RES:\n\n\t\t\t\t# Hydrogen\n\t\t\t\tif a_atom_symbol[i_element] == \"H\":\n\t\t\t\t\ts_custom_type = \"H\"\n\n\t\t\t\t# If the atom is one of the main carbon chain\n\t\t\t\telif a_atom_name[i_element] in d_translate_custom.keys():\n\t\t\t\t\ts_custom_type = d_translate_custom[a_atom_name[i_element]]\n\n\t\t\t\t# Nitrogen in Arginine\n\t\t\t\telif a_residue_names[i_element] == \"ARG\" and a_atom_name[i_element] in elem_config.NARG[a_residue_names[i_element]]:\n\t\t\t\t\ts_custom_type = \"NBAS\"\n\n\t\t\t\t# Carbon SP2 in aromatic ring\n\t\t\t\telif a_residue_names[i_element] in elem_config.CAR.keys() and a_atom_name[i_element] in elem_config.CAR[a_residue_names[i_element]]:\n\t\t\t\t\ts_custom_type = \"CAR\"\n\n\t\t\t\t# Oxygen in hydroxyl or phenol\n\t\t\t\telif a_residue_names[i_element] in elem_config.OHY.keys() and a_atom_name[i_element] == elem_config.OHY[a_residue_names[i_element]]:\n\t\t\t\t\ts_custom_type = \"OH\"\n\n\t\t\t\t# Nitrogen in amide\n\t\t\t\telif a_residue_names[i_element] in elem_config.NAM.keys() and a_atom_name[i_element] == elem_config.NAM[a_residue_names[i_element]]:\n\t\t\t\t\ts_custom_type = \"NAM\"\n\n\t\t\t\t# Nitrogen in Histidine\n\t\t\t\telif a_residue_names[i_element] in elem_config.NHIS.keys() and a_atom_name[i_element] in elem_config.NHIS[a_residue_names[i_element]]:\n\t\t\t\t\ts_custom_type = \"NBAS\"\n\n\t\t\t\t# Central carbon from ARG, GLN, GLU, ASP, ASN\n\t\t\t\telif a_residue_names[i_element] in elem_config.CE.keys() and elem_config.CE[a_residue_names[i_element]] == a_atom_name[i_element]:\n\t\t\t\t\ts_custom_type = \"CAR\"\n\n\t\t\t\t# Oxygen in carbonyl\n\t\t\t\telif a_residue_names[i_element] in elem_config.OC.keys() and a_atom_name[i_element] == elem_config.OC[a_residue_names[i_element]]:\n\t\t\t\t\ts_custom_type = \"OC\"\n\n\t\t\t\t# Oxygen in carboxylate and oxygen in C-terminal\n\t\t\t\telif a_residue_names[i_element] in elem_config.OOX.keys() and \\\n\t\t\t\t\t\t(a_atom_name[i_element] == elem_config.OOX[a_residue_names[i_element]][0] or\n\t\t\t\t\t\t a_atom_name[i_element] == elem_config.OOX[a_residue_names[i_element]][1]):\n\t\t\t\t\ts_custom_type = \"OOX\"\n\n\t\t\t\t# Nitrogen in Lysine\n\t\t\t\telif a_residue_names[i_element] in elem_config.NLYS.keys() and a_atom_name[i_element] == elem_config.NLYS[a_residue_names[i_element]]:\n\t\t\t\t\ts_custom_type = \"NBAS\"\n\n\t\t\t\t# Unknown element within a amino acid\n\t\t\t\telse:\n\t\t\t\t\ts_custom_type = \"XOT\"\n\t\t\t# End if\n\n\t\t\t# If the element is a metallic atom\n\t\t\telif a_atom_symbol[i_element] in elem_config.METAL:\n\t\t\t\ts_custom_type = \"META\"\n\n\t\t\t# If the element is a halogen\n\t\t\telif a_atom_symbol[i_element] in elem_config.HALO:\n\t\t\t\ts_custom_type = \"HALO\"\n\n\t\t\t# If the element is a water molecule\n\t\t\telif a_residue_names[i_element] == \"HOH\" and a_atom_name[i_element] == \"O\":\n\t\t\t\ts_custom_type = \"OOW\"\n\n\t\t\t# If the element is not known\n\t\t\telse:\n\n\t\t\t\t# If the element can be converted\n\t\t\t\tif a_atom_symbol[i_element] in d_translate_custom.keys():\n\t\t\t\t\ts_custom_type = d_translate_custom[a_atom_symbol[i_element]]\n\n\t\t\t\t# If it cannot\n\t\t\t\telse:\n\t\t\t\t\ts_custom_type = \"HETATM\"\n\t\t\t# End if\n\n\t\t\tl_s_custom_types.append(s_custom_type)\t\t# Saves the new element type\n\t\t# End for\n\t\t# END STEP 1 ---------------------------------------- #\n\n\t\t# STEP 2 : Saving the list of custom types ---------- #\n\t\tself.a_atoms[\"custom_type\"] = l_s_custom_types\t\t# Saves the list of custom types\n\t\t# END STEP 2 ---------------------------------------- #","def header_hook(header, data):\n\n for e in header.enums:\n e[\"x_namespace\"] = e[\"namespace\"]","def namespace_for(uri: Union[URIRef, Namespace, str]) -> str:\n uri = str(uri)\n if uri not in namespaces.values():\n namespaces[AnonNS().ns] = uri\n return [k for k, v in namespaces.items() if uri == v][0]","def hasNamespaceNS(self, *args):\n return _libsbml.XMLToken_hasNamespaceNS(self, *args)","def _getElement(self, element, literal=False, local=False, namespaceURI=None):\r\n if not element.isElement():\r\n raise TypeError, 'Expecting an ElementDeclaration'\r\n\r\n tc = None\r\n elementName = element.getAttribute('name')\r\n tp = element.getTypeDefinition('type')\r\n\r\n typeObj = None\r\n if not (tp or element.content):\r\n nsuriType,localName = element.getAttribute('type')\r\n typeClass = self._getTypeClass(nsuriType,localName)\r\n \r\n typeObj = typeClass(elementName)\r\n elif not tp:\r\n tp = element.content\r\n\r\n if not typeObj:\r\n typeObj = self._getType(tp, elementName, literal, local, namespaceURI)\r\n\r\n minOccurs = int(element.getAttribute('minOccurs'))\r\n typeObj.optional = not minOccurs\r\n\r\n maxOccurs = element.getAttribute('maxOccurs')\r\n typeObj.repeatable = (maxOccurs == 'unbounded') or (int(maxOccurs) > 1)\r\n\r\n return typeObj","def xmlrpc_namespace():","def test_xml_to_dict_net_namespace(self):\n xml = \"\"\"\n \n b\n \n \n \"\"\"\n xmlns = {\n \"_\": utils.NETCONF_NAMESPACE\n }\n result = utils.generate_dict_node(etree.XML(xml), xmlns)\n # check dict\n self.assertEqual(\n {'a': {'_something@b': 'b'}},\n result\n )\n # check xmlns\n self.assertEqual(\n {\n '_': utils.NETCONF_NAMESPACE,\n '_something': 'something'\n }, xmlns\n )","def __init__ (self, ns_or_tagraw, pred=None, value=None) :\n self.__namespace__ = None\n self.__predicate__ = None\n self.__value__ = None\n self.__ismachinetag__ = False\n self.__isnumeric__ = False\n\n if pred :\n\n re_nspred = re.compile(r\"^([a-z](?:[a-z0-9_]+))$\", re.IGNORECASE)\n\n if re_nspred.match(ns_or_tagraw) and re_nspred.match(pred) and value :\n self.__namespace__ = ns_or_tagraw\n self.__predicate__ = pred\n self.__value__ = value\n else :\n\n re_tag = re.compile(r\"^([a-z](?:[a-z0-9_]+))\\:([a-z](?:[a-z0-9_]+))\\=(.+)$\", re.IGNORECASE)\n m = re_tag.findall(ns_or_tagraw)\n\n if m :\n self.__namespace__ = m[0][0]\n self.__predicate__ = m[0][1]\n self.__value__ = m[0][2]\n\n if self.__namespace__ and self.__predicate__ and self.__value__ :\n self.__ismachinetag__ = True\n\n valtype = type(self.__value__)\n\n if valtype == types.IntType or valtype == types.FloatType :\n self.__isnumeric__ = True\n else :\n re_num = re.compile(r\"^-?\\d+(\\.\\d+)?$\", re.IGNORECASE)\n m = re_num.findall(self.__value__)\n\n if m :\n\n self.__isnumeric__ = True\n self.__value__ = unicode(self.__value__)\n\n if m[0] :\n self.__value_numeric__ = float(self.__value__)\n else :\n self.__value_numeric__ = int(self.__value__)","def test_getLocalType(self):\n cases = [\n (self.test_eac + \"NE00800.xml\", \"Archival Series\"),\n (self.test_eac + \"NE00916.xml\", \"Archival Collection\"),\n (self.test_eac + \"NE01201.xml\", \"Person\"),\n (self.test_eac + \"NE01000.xml\", \"Glossary Term\"),\n ]\n for case in cases:\n source, expected = case\n doc = EacCpf.EacCpf(source,'http://www.example.com')\n self.assertNotEqual(doc, None)\n result = doc.getLocalType()\n self.assertEqual(result, expected)","def hasURI(self, *args):\n return _libsbml.XMLNamespaces_hasURI(self, *args)","def getNamespace(self):\n pass;","def idl_type(field, namespace):\n\n out = ''\n if field.is_map:\n out = 'map <{0},'.format(idl_type(field.map_key, namespace))\n\n if field.is_array:\n out += 'repeated '\n\n if field.data_type in (schema.Field.DataType.STRUCT,\n schema.Field.DataType.ENUM):\n out += field.metadata.full_name.replace(namespace, '').strip('.')\n else:\n out += field.data_type.value\n\n if field.is_map:\n out += '>'\n\n return out","def namespaces(self):\n return ()","def getNamespace(self, parent: ghidra.program.model.symbol.Namespace, namespaceName: unicode) -> ghidra.program.model.symbol.Namespace:\n ...","def test_get_namespaces_names(self):\n pass","def _getTypeCode(self, parameters, literal=False):\r\n ofwhat = []\r\n for part in parameters:\r\n namespaceURI,localName = part.type\r\n\r\n if part.element_type:\r\n #global element\r\n element = self._wsdl.types[namespaceURI].elements[localName]\r\n tc = self._getElement(element, literal=literal, local=False, namespaceURI=namespaceURI)\r\n else:\r\n #local element\r\n name = part.name\r\n typeClass = self._getTypeClass(namespaceURI, localName)\r\n if not typeClass:\r\n tp = self._wsdl.types[namespaceURI].types[localName]\r\n tc = self._getType(tp, name, literal, local=True, namespaceURI=namespaceURI)\r\n else:\r\n tc = typeClass(name)\r\n ofwhat.append(tc)\r\n return ofwhat","def _match_entry_type_string(code_entry, string_list):\n entry_type = re.match(r\"<(AST.*):.*\", code_entry.get('type')).group(1)\n return bool(entry_type in string_list)","def type(self) -> global___Type:","def _getPrefix(self, namespaceURI):\r\n prefixDict = self._getPrefixDict()\r\n if prefixDict.has_key(namespaceURI):\r\n prefix = prefixDict[namespaceURI]\r\n else:\r\n prefix = 'ns1'\r\n while prefix in prefixDict.values():\r\n prefix = 'ns%d' %int(prefix[-1]) + 1\r\n prefixDict[namespaceURI] = prefix\r\n return prefix","def test_createElementNS():\n\n assert not _do_test_raw(\"\"\"\n var x = \"foo\";\n x.createElementNS();\n x.createElementNS(\"foo\");\n x.createElementNS(\"foo\", \"bar\");\n \"\"\").failed()\n\n assert _do_test_raw(\"\"\"\n var x = \"foo\";\n x.createElementNS(\"foo\", \"script\");\n \"\"\").failed()\n\n assert _do_test_raw(\"\"\"\n var x = \"foo\";\n x.createElementNS(\"foo\", bar);\n \"\"\").failed()\n\n # Test for https://github.com/mozilla/amo-validator/issues/368\n assert not _do_test_raw(\"\"\"\n var x = \"foo\",\n nsXUL = \"http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul\";\n\n x.createElementNS(nsXUL, 'panelview')\n \"\"\").failed()\n\n # Creating a
', '\\n')\n if not error_message:\n return {'error': 'no error message supplied'}\n commit = entity.repo.get_commit(version)\n\n if ERROR_FILE_NAME in commit.filenames:\n logger.warning('Error file already exists in commit. New error message is: %s', error_message)\n else:\n content = b'Error analysing protocol:\\n\\n' + error_message.encode('UTF-8')\n commit.add_ephemeral_file(ERROR_FILE_NAME, content)\n # Don't try to analyse this protocol again\n cached_version = entity.repocache.get_version(version)\n cached_version.parsed_ok = False\n cached_version.save()\n ProtocolIoputs(protocol_version=cached_version, name=' ', kind=ProtocolIoputs.FLAG).save()\n\n return {}","def test_get_request_output(self):\n pass","def _process_convert_output_(self, output_data, **kwargs):\n accept_input, current_state, output = output_data\n if kwargs['full_output']:\n if current_state.label() is None:\n return (accept_input, current_state, None)\n else:\n return (accept_input, current_state, output)\n else:\n if not accept_input:\n return None\n return output","def _process_convert_output_(self, output_data, **kwargs):\n accept_input, current_state, output = output_data\n return (accept_input, current_state, output)","def post_call(self, date='2014-02-12', time='22:20:33', rnumber='0674767730', rname='Romain', snumber='0617382221', sname='Lolo'):\n xmldata1 = \"\" + \\\n \"
', '\\\\n')\\n if not error_message:\\n return {'error': 'no error message supplied'}\\n commit = entity.repo.get_commit(version)\\n\\n if ERROR_FILE_NAME in commit.filenames:\\n logger.warning('Error file already exists in commit. New error message is: %s', error_message)\\n else:\\n content = b'Error analysing protocol:\\\\n\\\\n' + error_message.encode('UTF-8')\\n commit.add_ephemeral_file(ERROR_FILE_NAME, content)\\n # Don't try to analyse this protocol again\\n cached_version = entity.repocache.get_version(version)\\n cached_version.parsed_ok = False\\n cached_version.save()\\n ProtocolIoputs(protocol_version=cached_version, name=' ', kind=ProtocolIoputs.FLAG).save()\\n\\n return {}\",\n \"def test_get_request_output(self):\\n pass\",\n \"def _process_convert_output_(self, output_data, **kwargs):\\n accept_input, current_state, output = output_data\\n if kwargs['full_output']:\\n if current_state.label() is None:\\n return (accept_input, current_state, None)\\n else:\\n return (accept_input, current_state, output)\\n else:\\n if not accept_input:\\n return None\\n return output\",\n \"def _process_convert_output_(self, output_data, **kwargs):\\n accept_input, current_state, output = output_data\\n return (accept_input, current_state, output)\",\n \"def post_call(self, date='2014-02-12', time='22:20:33', rnumber='0674767730', rname='Romain', snumber='0617382221', sname='Lolo'):\\n xmldata1 = \\\"\\\" + \\\\\\n \\\"