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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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)<percent_calc)\n z_mi = np.zeros( (len(rs),max_lag) )\n\n for i, (rs,cs) in enumerate(zip(r_picks,c_picks)):\n for j in range(max_lag):\n\n ind=j+1\n\n unshift = M[rs, cs, ind:]\n shift = M[rs, cs, :-ind]\n z_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 z_mut = np.mean(z_mi,axis=0)\n\n return r_mut, c_mut, z_mut","def apply_per_reducts_cmip6():\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 #Get the year-on-year proportional reductions in RCP2.6\n yoy_rates = calc_perc_reducts()\n yoy_rates = np.array(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 year on year proportional reductions (globally uniform) from RCP2.6 in 2015 onwards\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_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)<edge_thresh] = np.nan\n\t\t\tfor driver_nodes in driver_nodes_list:\n\t\t\t\tweight_change_matrix_between = np.zeros((num_nodes,num_nodes))\n\t\t\t\tweight_change_matrix_within = np.zeros((num_nodes,num_nodes))\n\t\t\t\tif driver_nodes == 'Q-':\n\t\t\t\t\tdriver_nodes_array = local_nodes\n\t\t\t\telse:\n\t\t\t\t\tdriver_nodes_array = connector_nodes\n\t\t\t\tfor n1,n2 in permutations(range(num_nodes),2):\n\t\t\t\t\tif n1 not in driver_nodes_array:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tif known_membership[n2] == 0:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tarray = pc_edge_corr[n1][n2]\n\t\t\t\t\tweight_change_matrix_between[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership!=known_membership[n2])&(np.arange(264)!=n1))])\n\t\t\t\t\tweight_change_matrix_within[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership==known_membership[n2])&(np.arange(264)!=n1))])\n\t\t\t\t\t# for n3 in range(264):\n\t\t\t\t\t# \tif n1 == n3:\n\t\t\t\t\t# \t\tcontinue\n\t\t\t\t\t# \tif known_membership[n3]!= known_membership[n2]:\n\t\t\t\t\t# \t\tweight_change_matrix_between[n1,n2] = np.nansum([weight_change_matrix_between[n1,n2],array[n3]])\n\t\t\t\t\t# \t\tbetween_len = between_len + 1\n\t\t\t\t\t# \telse:\n\t\t\t\t\t# \t\tweight_change_matrix_within[n1,n2] = np.nansum([weight_change_matrix_within[n1,n2],array[n3]])\n\t\t\t\t\t# \t\tcommunity_len = community_len + 1\n\t\t\t\t\t# weight_change_matrix_within[n1,n2] = weight_change_matrix_within[n1,n2] / community_len\n\t\t\t\t\t# weight_change_matrix_between[n1,n2] = weight_change_matrix_between[n1,n2] / between_len\n\t\t\t\ttemp_matrix = np.nanmean(matrices,axis=0)\n\t\t\t\tweight_matrix = weight_change_matrix_within-weight_change_matrix_between\n\t\t\t\tweight_matrix[np.isnan(weight_matrix)] = 0.0\n\t\t\t\tif hub_node == 'PC':\n\t\t\t\t\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\"Strength of r's, i's PC & j's Q\"]\n\t\t\t\telse:\n\t\t\t\t\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\"Strength of r's, i's WCD & j's Q\"]\n\t\t\t\tdf_array = []\n\t\t\t\tfor i,j in zip(temp_matrix[weight_matrix!=0.0].reshape(-1),weight_matrix[weight_matrix!=0.0].reshape(-1)):\n\t\t\t\t\tdf_array.append([task,hub_node,driver_nodes,i,j])\n\t\t\t\tdf = pd.concat([df,pd.DataFrame(df_array,columns=df_columns)],axis=0)\n\t\t\t\tprint hub_node, driver_nodes\n\t\t\t\tprint pearsonr(weight_matrix[weight_matrix!=0.0].reshape(-1),temp_matrix[weight_matrix!=0.0].reshape(-1))\n\t\t\t\t1/0\n\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='PC')],\"Strength of r's, i's PC & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqplus_%s.pdf'%(edge_thresh_val))\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='PC')],\"Strength of r's, i's PC & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqminus_%s.pdf'%(edge_thresh_val))\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='WCD')],\"Strength of r's, i's WCD & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqplus_%s.pdf'%(edge_thresh_val))\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='WCD')],\"Strength of r's, i's WCD & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqminus_%s.pdf'%(edge_thresh_val))\n\t# \"\"\"\n\t# Are connector nodes modulating the edges that are most variable across subjects?\n\t# \"\"\"\n\t# atlas='power'\n\t# known_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\n\t# for task in tasks:\n\t# \tpc_thresh = 75\n\t# \tlocal_thresh = 25\n\t# \tsubjects = np.array(hcp_subjects).copy()\n\t# \tsubjects = list(subjects)\n\t# \tsubjects = remove_missing_subjects(subjects,task,atlas)\n\t# \tstatic_results = graph_metrics(subjects,task,atlas)\n\t# \tsubject_pcs = static_results['subject_pcs']\n\t# \tsubject_wmds = static_results['subject_wmds']\n\t# \tmatrices = static_results['matrices']\n\t# \tmatrices[:,np.nanmean(matrices,axis=0)<0.0] = np.nan\n\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# pc_edge_corr = 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# \tstd_mod = []\n\t# \ttstd = np.std(matrices,axis=0).reshape(-1)\n\t# \tfor i in range(num_nodes):\n\t# \t\tstd_mod.append(nan_pearsonr(pc_edge_corr[i].reshape(-1),tstd)[0])\n\t# \t# print task, pearsonr(np.nanmean(subject_pcs,axis=0),std_mod)\n\t# \tprint task, pearsonr(np.nanmean(subject_wmds,axis=0),std_mod)\n\t# \tplot_corr_matrix(np.std(matrices,axis=0),network_names.copy(),out_file=None,plot_corr=True,return_array=False)","def calc(self):\n\t\tfor neuron in self.neurons.items():\n\t\t\tneuron.calculate()","def calculate_conservation(self):\n for pchain in self.system.ProteinList:\n ConservationTools.fetch_msq_conservation(pchain)\n ConservationTools.calculate_conservation(self.system)\n self.rebuild_color_menu()","def _compute_outputs(self, *args, **kwargs):\n pass\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\n # self.logits = self.outputs[0][0]\n # self.probs = torch.softmax(self.logits, 1)","def back_propagate(self,y):\n if y.ndim > 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_temp<minlos))))\n maps_temp[kk] = float('NaN')\n\n itemp = ibeg_emp\n for lign in range(ibeg_emp,iend_emp,10):\n if np.isnan(np.nanmean(maps[lign:lign+10,:,l])):\n itemp = lign\n else:\n break\n logger.debug('Begining of the image: {}'.format(itemp))\n\n if arguments[\"--topofile\"] is not None:\n ax_dphi = fig_dphi.add_subplot(4,int(N/4)+1,l+1)\n else:\n ax_dphi = None\n\n logger.debug('Threshold RMS: {}'.format(float(arguments[\"--threshold_rms\"])))\n\n # selection pixels\n index = np.nonzero(np.logical_and(elev<maxtopo,\n np.logical_and(elev>mintopo,\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(rmsmap<float(arguments[\"--threshold_rms\"]),\n np.logical_and(rmsmap>1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>ibeg_emp,\n np.logical_and(pix_az<iend_emp,\n np.logical_and(pix_rg>jbeg_emp,\n np.logical_and(pix_rg<jend_emp, \n slope>0.,\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(elev<maxtopo,\n np.logical_and(elev>mintopo,\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(rmsmap<float(arguments[\"--threshold_rms\"]),\n np.logical_and(rmsmap>1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>lin_start,\n np.logical_and(pix_az<lin_end,\n np.logical_and(pix_rg>col_start,\n np.logical_and(pix_rg<col_end, \n slope>0.,\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))<np.mean(W_idct_hat)+np.float64(10**-5))[:,0],:]\n R1_lower = np.mean(R1_lower[:,validA1coeff_idx],0)\n B1_coeff = (R1_upper-R1_lower)/np.mean(R1)\n k = validA1coeff_idx.size\n\n # Calculate the darkfield offset\n temp1 = np.sum(np.square(A_coeff[0,validA1coeff_idx]))\n temp2 = np.sum(A_coeff[0,validA1coeff_idx])\n temp3 = np.sum(B1_coeff)\n temp4 = np.sum(A_coeff[0,validA1coeff_idx]*B1_coeff)\n temp5 = temp2 * temp3 - k*temp4\n if temp5 == 0:\n B1_offset = np.float64(0)\n else:\n B1_offset = (temp1*temp3-temp2*temp4)/temp5\n B1_offset = np.max(B1_offset,initial=0)\n B1_offset = np.min(B1_offset,initial=B1_uplimit/(np.mean(W_idct_hat)+10**-7))\n B_offset = B1_offset * np.mean(W_idct_hat) - B1_offset*np.reshape(W_idct_hat,(-1,1))\n\n # Calculate darkfield\n A1_offset = np.reshape(np.mean(R1[:,validA1coeff_idx],1),(-1,1)) - np.mean(A_coeff[0,validA1coeff_idx]) * np.reshape(W_idct_hat,(-1,1))\n A1_offset = A1_offset - np.mean(A1_offset)\n A_offset = A1_offset - np.mean(A1_offset) - B_offset\n\n # Update darkfield weights\n W_offset = _dct2(np.reshape(A_offset,(img_width, img_height)))\n W_offset = np.max(np.reshape(W_offset - options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0) \\\n + np.min(np.reshape(W_offset + options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0)\n\n # Calculate darkfield based on updated weights\n A_offset = _idct2(W_offset)\n A_offset = np.reshape(A_offset,(-1,1))\n A_offset = np.max(np.reshape(A_offset - options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0) \\\n + np.min(np.reshape(A_offset + options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0)\n A_offset = A_offset + B_offset\n\n # Loss\n Z1 = imgflt_stack - A - E1\n\n # Update weight regularization term\n Y1 = Y1 + mu*Z1\n\n # Update learning rate\n mu = np.min(mu*rho,initial=mu_bar)\n\n # Stop if loss is below threshold\n stopCriterion = np.linalg.norm(Z1,ord='fro')/d_norm\n if stopCriterion < options['optimization_tol'] or iternum > 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)<percent_calc)\\n z_mi = np.zeros( (len(rs),max_lag) )\\n\\n for i, (rs,cs) in enumerate(zip(r_picks,c_picks)):\\n for j in range(max_lag):\\n\\n ind=j+1\\n\\n unshift = M[rs, cs, ind:]\\n shift = M[rs, cs, :-ind]\\n z_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 z_mut = np.mean(z_mi,axis=0)\\n\\n return r_mut, c_mut, z_mut\",\n \"def apply_per_reducts_cmip6():\\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 #Get the year-on-year proportional reductions in RCP2.6\\n yoy_rates = calc_perc_reducts()\\n yoy_rates = np.array(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 year on year proportional reductions (globally uniform) from RCP2.6 in 2015 onwards\\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_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)<edge_thresh] = np.nan\\n\\t\\t\\tfor driver_nodes in driver_nodes_list:\\n\\t\\t\\t\\tweight_change_matrix_between = np.zeros((num_nodes,num_nodes))\\n\\t\\t\\t\\tweight_change_matrix_within = np.zeros((num_nodes,num_nodes))\\n\\t\\t\\t\\tif driver_nodes == 'Q-':\\n\\t\\t\\t\\t\\tdriver_nodes_array = local_nodes\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdriver_nodes_array = connector_nodes\\n\\t\\t\\t\\tfor n1,n2 in permutations(range(num_nodes),2):\\n\\t\\t\\t\\t\\tif n1 not in driver_nodes_array:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tif known_membership[n2] == 0:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tarray = pc_edge_corr[n1][n2]\\n\\t\\t\\t\\t\\tweight_change_matrix_between[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership!=known_membership[n2])&(np.arange(264)!=n1))])\\n\\t\\t\\t\\t\\tweight_change_matrix_within[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership==known_membership[n2])&(np.arange(264)!=n1))])\\n\\t\\t\\t\\t\\t# for n3 in range(264):\\n\\t\\t\\t\\t\\t# \\tif n1 == n3:\\n\\t\\t\\t\\t\\t# \\t\\tcontinue\\n\\t\\t\\t\\t\\t# \\tif known_membership[n3]!= known_membership[n2]:\\n\\t\\t\\t\\t\\t# \\t\\tweight_change_matrix_between[n1,n2] = np.nansum([weight_change_matrix_between[n1,n2],array[n3]])\\n\\t\\t\\t\\t\\t# \\t\\tbetween_len = between_len + 1\\n\\t\\t\\t\\t\\t# \\telse:\\n\\t\\t\\t\\t\\t# \\t\\tweight_change_matrix_within[n1,n2] = np.nansum([weight_change_matrix_within[n1,n2],array[n3]])\\n\\t\\t\\t\\t\\t# \\t\\tcommunity_len = community_len + 1\\n\\t\\t\\t\\t\\t# weight_change_matrix_within[n1,n2] = weight_change_matrix_within[n1,n2] / community_len\\n\\t\\t\\t\\t\\t# weight_change_matrix_between[n1,n2] = weight_change_matrix_between[n1,n2] / between_len\\n\\t\\t\\t\\ttemp_matrix = np.nanmean(matrices,axis=0)\\n\\t\\t\\t\\tweight_matrix = weight_change_matrix_within-weight_change_matrix_between\\n\\t\\t\\t\\tweight_matrix[np.isnan(weight_matrix)] = 0.0\\n\\t\\t\\t\\tif hub_node == 'PC':\\n\\t\\t\\t\\t\\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\\\"Strength of r's, i's PC & j's Q\\\"]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\\\"Strength of r's, i's WCD & j's Q\\\"]\\n\\t\\t\\t\\tdf_array = []\\n\\t\\t\\t\\tfor i,j in zip(temp_matrix[weight_matrix!=0.0].reshape(-1),weight_matrix[weight_matrix!=0.0].reshape(-1)):\\n\\t\\t\\t\\t\\tdf_array.append([task,hub_node,driver_nodes,i,j])\\n\\t\\t\\t\\tdf = pd.concat([df,pd.DataFrame(df_array,columns=df_columns)],axis=0)\\n\\t\\t\\t\\tprint hub_node, driver_nodes\\n\\t\\t\\t\\tprint pearsonr(weight_matrix[weight_matrix!=0.0].reshape(-1),temp_matrix[weight_matrix!=0.0].reshape(-1))\\n\\t\\t\\t\\t1/0\\n\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='PC')],\\\"Strength of r's, i's PC & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqplus_%s.pdf'%(edge_thresh_val))\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='PC')],\\\"Strength of r's, i's PC & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqminus_%s.pdf'%(edge_thresh_val))\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='WCD')],\\\"Strength of r's, i's WCD & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqplus_%s.pdf'%(edge_thresh_val))\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='WCD')],\\\"Strength of r's, i's WCD & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqminus_%s.pdf'%(edge_thresh_val))\\n\\t# \\\"\\\"\\\"\\n\\t# Are connector nodes modulating the edges that are most variable across subjects?\\n\\t# \\\"\\\"\\\"\\n\\t# atlas='power'\\n\\t# known_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\\n\\t# for task in tasks:\\n\\t# \\tpc_thresh = 75\\n\\t# \\tlocal_thresh = 25\\n\\t# \\tsubjects = np.array(hcp_subjects).copy()\\n\\t# \\tsubjects = list(subjects)\\n\\t# \\tsubjects = remove_missing_subjects(subjects,task,atlas)\\n\\t# \\tstatic_results = graph_metrics(subjects,task,atlas)\\n\\t# \\tsubject_pcs = static_results['subject_pcs']\\n\\t# \\tsubject_wmds = static_results['subject_wmds']\\n\\t# \\tmatrices = static_results['matrices']\\n\\t# \\tmatrices[:,np.nanmean(matrices,axis=0)<0.0] = np.nan\\n\\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# pc_edge_corr = 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# \\tstd_mod = []\\n\\t# \\ttstd = np.std(matrices,axis=0).reshape(-1)\\n\\t# \\tfor i in range(num_nodes):\\n\\t# \\t\\tstd_mod.append(nan_pearsonr(pc_edge_corr[i].reshape(-1),tstd)[0])\\n\\t# \\t# print task, pearsonr(np.nanmean(subject_pcs,axis=0),std_mod)\\n\\t# \\tprint task, pearsonr(np.nanmean(subject_wmds,axis=0),std_mod)\\n\\t# \\tplot_corr_matrix(np.std(matrices,axis=0),network_names.copy(),out_file=None,plot_corr=True,return_array=False)\",\n \"def calc(self):\\n\\t\\tfor neuron in self.neurons.items():\\n\\t\\t\\tneuron.calculate()\",\n \"def calculate_conservation(self):\\n for pchain in self.system.ProteinList:\\n ConservationTools.fetch_msq_conservation(pchain)\\n ConservationTools.calculate_conservation(self.system)\\n self.rebuild_color_menu()\",\n \"def _compute_outputs(self, *args, **kwargs):\\n pass\\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\\n # self.logits = self.outputs[0][0]\\n # self.probs = torch.softmax(self.logits, 1)\",\n \"def back_propagate(self,y):\\n if y.ndim > 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_temp<minlos))))\\n maps_temp[kk] = float('NaN')\\n\\n itemp = ibeg_emp\\n for lign in range(ibeg_emp,iend_emp,10):\\n if np.isnan(np.nanmean(maps[lign:lign+10,:,l])):\\n itemp = lign\\n else:\\n break\\n logger.debug('Begining of the image: {}'.format(itemp))\\n\\n if arguments[\\\"--topofile\\\"] is not None:\\n ax_dphi = fig_dphi.add_subplot(4,int(N/4)+1,l+1)\\n else:\\n ax_dphi = None\\n\\n logger.debug('Threshold RMS: {}'.format(float(arguments[\\\"--threshold_rms\\\"])))\\n\\n # selection pixels\\n index = np.nonzero(np.logical_and(elev<maxtopo,\\n np.logical_and(elev>mintopo,\\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(rmsmap<float(arguments[\\\"--threshold_rms\\\"]),\\n np.logical_and(rmsmap>1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>ibeg_emp,\\n np.logical_and(pix_az<iend_emp,\\n np.logical_and(pix_rg>jbeg_emp,\\n np.logical_and(pix_rg<jend_emp, \\n slope>0.,\\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(elev<maxtopo,\\n np.logical_and(elev>mintopo,\\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(rmsmap<float(arguments[\\\"--threshold_rms\\\"]),\\n np.logical_and(rmsmap>1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>lin_start,\\n np.logical_and(pix_az<lin_end,\\n np.logical_and(pix_rg>col_start,\\n np.logical_and(pix_rg<col_end, \\n slope>0.,\\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))<np.mean(W_idct_hat)+np.float64(10**-5))[:,0],:]\\n R1_lower = np.mean(R1_lower[:,validA1coeff_idx],0)\\n B1_coeff = (R1_upper-R1_lower)/np.mean(R1)\\n k = validA1coeff_idx.size\\n\\n # Calculate the darkfield offset\\n temp1 = np.sum(np.square(A_coeff[0,validA1coeff_idx]))\\n temp2 = np.sum(A_coeff[0,validA1coeff_idx])\\n temp3 = np.sum(B1_coeff)\\n temp4 = np.sum(A_coeff[0,validA1coeff_idx]*B1_coeff)\\n temp5 = temp2 * temp3 - k*temp4\\n if temp5 == 0:\\n B1_offset = np.float64(0)\\n else:\\n B1_offset = (temp1*temp3-temp2*temp4)/temp5\\n B1_offset = np.max(B1_offset,initial=0)\\n B1_offset = np.min(B1_offset,initial=B1_uplimit/(np.mean(W_idct_hat)+10**-7))\\n B_offset = B1_offset * np.mean(W_idct_hat) - B1_offset*np.reshape(W_idct_hat,(-1,1))\\n\\n # Calculate darkfield\\n A1_offset = np.reshape(np.mean(R1[:,validA1coeff_idx],1),(-1,1)) - np.mean(A_coeff[0,validA1coeff_idx]) * np.reshape(W_idct_hat,(-1,1))\\n A1_offset = A1_offset - np.mean(A1_offset)\\n A_offset = A1_offset - np.mean(A1_offset) - B_offset\\n\\n # Update darkfield weights\\n W_offset = _dct2(np.reshape(A_offset,(img_width, img_height)))\\n W_offset = np.max(np.reshape(W_offset - options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0) \\\\\\n + np.min(np.reshape(W_offset + options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0)\\n\\n # Calculate darkfield based on updated weights\\n A_offset = _idct2(W_offset)\\n A_offset = np.reshape(A_offset,(-1,1))\\n A_offset = np.max(np.reshape(A_offset - options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0) \\\\\\n + np.min(np.reshape(A_offset + options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0)\\n A_offset = A_offset + B_offset\\n\\n # Loss\\n Z1 = imgflt_stack - A - E1\\n\\n # Update weight regularization term\\n Y1 = Y1 + mu*Z1\\n\\n # Update learning rate\\n mu = np.min(mu*rho,initial=mu_bar)\\n\\n # Stop if loss is below threshold\\n stopCriterion = np.linalg.norm(Z1,ord='fro')/d_norm\\n if stopCriterion < options['optimization_tol'] or iternum > 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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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<w.x><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<xmax:\n w = np.where((x>=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<w.x><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<xmax:\\n w = np.where((x>=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]","isConversational":false},"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]","isConversational":false},"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(\"<class \")[-1].split(\"'\")\n if len(splits) > 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 <customtag impl=\"{tag}\" attr1=\"...\" attr2=\"...\"/>. '\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(\\\"<class \\\")[-1].split(\\\"'\\\")\\n if len(splits) > 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 <customtag impl=\\\"{tag}\\\" attr1=\\\"...\\\" attr2=\\\"...\\\"/>. '\\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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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('<br/>', '\\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 = \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\" + \\\n \"<s:Envelope xmlns:s=\\\"http://schemas.xmlsoap.org/soap/envelope/\\\" s:encodingStyle=\\\"http://schemas.xmlsoap.org/soap/encoding/\\\">\" + \\\n \"<s:Body>\" + \\\n \"<u:AddMessage xmlns:u=\\\"urn:samsung.com:service:MessageBoxService:1\\\">\" + \\\n \"<MessageType>text/xml</MessageType>\" + \\\n \"<MessageID>call</MessageID>\" + \\\n \"<Message>\" + \\\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 \"</Message>\" + \\\n \"</u:AddMessage>\" + \\\n \"</s:Body>\" + \\\n \"</s:Envelope>\"\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 <operation> < 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 # <SERVICE>: {\n # <REQUEST>: [\n # <optional layers param>, <mandatory layers param>\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('<br/>', '\\\\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 = \\\"<?xml version=\\\\\\\"1.0\\\\\\\" encoding=\\\\\\\"UTF-8\\\\\\\"?>\\\" + \\\\\\n \\\"<s:Envelope xmlns:s=\\\\\\\"http://schemas.xmlsoap.org/soap/envelope/\\\\\\\" s:encodingStyle=\\\\\\\"http://schemas.xmlsoap.org/soap/encoding/\\\\\\\">\\\" + \\\\\\n \\\"<s:Body>\\\" + \\\\\\n \\\"<u:AddMessage xmlns:u=\\\\\\\"urn:samsung.com:service:MessageBoxService:1\\\\\\\">\\\" + \\\\\\n \\\"<MessageType>text/xml</MessageType>\\\" + \\\\\\n \\\"<MessageID>call</MessageID>\\\" + \\\\\\n \\\"<Message>\\\" + \\\\\\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 \\\"</Message>\\\" + \\\\\\n \\\"</u:AddMessage>\\\" + \\\\\\n \\\"</s:Body>\\\" + \\\\\\n \\\"</s:Envelope>\\\"\\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 <operation> < 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 # <SERVICE>: {\\n # <REQUEST>: [\\n # <optional layers param>, <mandatory layers param>\\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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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]","isConversational":false},"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 <a\n xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\"\n >\n <b xmlns=\"something\">b</b>\n <!-- Comment, ignore it -->\n </a>\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 <script> element raises a warning of course.\n assert _do_test_raw(\"\"\"\n var x = \"foo\",\n nsXUL = \"http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul\";\n\n x.createElementNS(nsXUL, 'script')\n \"\"\").failed()","def _fixNS(self, namespace):\n if isinstance(namespace, bytes):\n namespace = str(namespace, encoding=\"utf-8\")\n\n if namespace == OPENID_NS:\n if self._openid_ns_uri is None:\n raise UndefinedOpenIDNamespace('OpenID namespace not set')\n else:\n namespace = self._openid_ns_uri\n\n if namespace != BARE_NS and not isinstance(namespace, str):\n raise TypeError(\n \"Namespace must be BARE_NS, OPENID_NS or a string. got %r\" %\n (namespace, ))\n\n if namespace != BARE_NS and ':' not in namespace:\n fmt = 'OpenID 2.0 namespace identifiers SHOULD be URIs. Got %r'\n warnings.warn(fmt % (namespace, ), DeprecationWarning)\n\n if namespace == 'sreg':\n fmt = 'Using %r instead of \"sreg\" as namespace'\n warnings.warn(\n fmt % (SREG_URI, ),\n DeprecationWarning, )\n return SREG_URI\n\n return namespace","def containsUri(self, *args):\n return _libsbml.XMLNamespaces_containsUri(self, *args)","def _get_element_ns(self, element):\n\n if (self._client == None):\n raise ValueError('Specification is not imported yet')\n\n ns = None\n for key in self._client.wsdl.schema.types.keys():\n if (key[0] == element):\n ns = key[1]\n break\n\n return ns","def SBMLNamespaces_isSBMLNamespace(*args):\n return _libsbml.SBMLNamespaces_isSBMLNamespace(*args)","def test_typedef00801m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00801m/typeDef00801m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00801m/typeDef00801m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def hasNS(self, *args):\n return _libsbml.XMLNamespaces_hasNS(self, *args)","def test_type_attribute(self):\n\n self._create_string()\n self.assertEquals(\"%s:%s\" % (\"xs\",\"string\"), self.string.schema_node.get(\"type\"))","def get_pyxb_namespaces():\n return pyxb.namespace.utility.AvailableNamespaces()","def _BuildTypeMaps(self, type_namespaces):\n for type_namespace in type_namespaces:\n self.type_namespaces_map[type_namespace.namespace] = type_namespace\n for entity_type in type_namespace.valid_types_map.values():\n if entity_type.guid:\n if entity_type.guid in self.type_guids_map:\n dup_guid_entry = self.type_guids_map[entity_type.guid]\n dup_guid_type = self.GetEntityType(dup_guid_entry.namespace,\n dup_guid_entry.typename)\n if dup_guid_type is None:\n raise RuntimeError('Duplicate type with guid ' + entity_type.guid\n + ' should always be mapped')\n entity_type.AddFinding(\n findings_lib.DuplicateGuidsError(type_namespace.namespace,\n entity_type, dup_guid_type))\n dup_guid_type.AddFinding(\n findings_lib.DuplicateGuidsError(dup_guid_entry.namespace,\n dup_guid_type, entity_type))\n self.type_guids_map[entity_type.guid] = EntityIdByEntry(\n namespace=type_namespace.namespace, typename=entity_type.typename)","def test_read_net_namespace(self):\n pass","def test_typedef00205m_type_def00205m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00205m/typeDef00205m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00205m/typeDef00205m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_typedef00802m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00802m/typeDef00802m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00802m/typeDef00802m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def get_type(self) -> str:\n # Note: this name conflicts with existing python builtins\n return self[\"Sns\"][\"Type\"]","def pyxb_get_type_name(obj_pyxb):\n return pyxb_get_namespace_name(obj_pyxb).split('}')[-1]","def getTypeCode(self):\n return _libsbml.ReplacedBy_getTypeCode(self)","def test_typedef00202m_type_def00202m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00202m/typeDef00202m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00202m/typeDef00202m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_typedef01201m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef01201m/typeDef01201m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef01201m/typeDef01201m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def astType(cls, source):\n if source == '':\n return cls.BLANK\n if source == \"OPENQASM 2.0;\":\n return cls.DECLARATION_QASM_2_0\n x = QTRegEx.COMMENT.search(source)\n if x:\n return cls.COMMENT\n x = QTRegEx.INCLUDE.search(source)\n if x:\n return cls.INCLUDE\n x = QTRegEx.CTL_2.search(source)\n if x:\n if x.group(1) == 'if':\n return cls.CTL_2\n x = QTRegEx.QREG.search(source)\n if x:\n return cls.QREG\n x = QTRegEx.CREG.search(source)\n if x:\n return cls.CREG\n x = QTRegEx.MEASURE.search(source)\n if x:\n return cls.MEASURE\n x = QTRegEx.BARRIER.search(source)\n if x:\n return cls.BARRIER\n x = QTRegEx.GATE.search(source)\n if x:\n return cls.GATE\n x = QTRegEx.OP.search(source)\n if x:\n return cls.OP\n return cls.UNKNOWN","def validateOneNamespace(self, doc, elem, prefix, ns, value):\n if doc is None: doc__o = None\n else: doc__o = doc._o\n if elem is None: elem__o = None\n else: elem__o = elem._o\n if ns is None: ns__o = None\n else: ns__o = ns._o\n ret = libxml2mod.xmlValidateOneNamespace(self._o, doc__o, elem__o, prefix, ns__o, value)\n return ret","def test_get_node_type_name(self):\n pass","def test_typedef00502m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00502m/typeDef00502m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00502m/typeDef00502m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_typedef00204m_type_def00204m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00204m/typeDef00204m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00204m/typeDef00204m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def SBMLNamespaces_getSupportedNamespaces():\n return _libsbml.SBMLNamespaces_getSupportedNamespaces()","def __generate_object_term__(self, datatype, value):\n if datatype == NS_MGR.xsd.anyURI.rdflib:\n term = rdflib.URIRef(value)\n elif datatype:\n term = rdflib.Literal(value, datatype=datatype)\n else:\n term = rdflib.Literal(value)\n return term","def XrefTypeName(typecode):\n assert typecode in _ref_types, \"unknown reference type %d\" % typecode\n return _ref_types[typecode]","def getTypeCode(self):\n return _libsbml.SBMLDocument_getTypeCode(self)","def test_typedef00203m_type_def00203m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00203m/typeDef00203m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00203m/typeDef00203m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def _BuildNamespaceFolderMap(self, type_folders):\n for folder in type_folders:\n self.namespace_folder_map[folder.local_namespace.namespace] = folder","def setOpenIDNamespace(self, openid_ns_uri, implicit):\n if isinstance(openid_ns_uri, bytes):\n openid_ns_uri = str(openid_ns_uri, encoding=\"utf-8\")\n if openid_ns_uri not in self.allowed_openid_namespaces:\n raise InvalidOpenIDNamespace(openid_ns_uri)\n\n self.namespaces.addAlias(openid_ns_uri, NULL_NAMESPACE, implicit)\n self._openid_ns_uri = openid_ns_uri","def explore_type(name, datatype, is_child):\n actual_type = datatype.strip_typedefs()\n if is_child:\n print (\"The type of %s is a typedef of type '%s'.\" %\n (name, str(actual_type)))\n else:\n print (\"The type '%s' is a typedef of type '%s'.\" %\n (name, str(actual_type)))\n\n Explorer.explore_type(name, actual_type, is_child)\n return False","def getTypeCode(self):\n return _libsbml.ReplacedElement_getTypeCode(self)","def get_type_label(type_url):\n return type_dict[type_url]","def _cim_scope_code_type():\n return {\n 'name' : 'cim_scope_code_type',\n 'is_open' : False,\n 'doc' : 'This would cover quality issues with the CIM itself',\n 'members' : [\n ('dataset', None),\n ('software', None),\n ('service', None),\n ('model', None),\n ('modelComponent', None),\n ('simulation', None),\n ('experiment', None),\n ('numericalRequirement', None),\n ('ensemble', None),\n ('file', None),\n ],\n }","def test_typedef00402m_type_def00402m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00402m/typeDef00402m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00402m/typeDef00402m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def _some_namespaces(self):\n n = Namespace(doc='top')\n n.add_option('aaa', '2011-05-04T15:10:00', 'the a',\n short_form='a',\n from_string_converter=dtu.datetime_from_ISO_string\n )\n n.c = Namespace(doc='c space')\n n.c.add_option('fred', 'stupid', 'husband from Flintstones')\n n.c.add_option('wilma', 'waspish', 'wife from Flintstones')\n n.c.e = Namespace(doc='e space')\n n.c.e.add_option('dwight',\n default=97,\n doc='my uncle')\n n.c.add_option('dwight',\n default=98,\n doc='your uncle')\n n.d = Namespace(doc='d space')\n n.d.add_option('fred', 'crabby', 'male neighbor from I Love Lucy')\n n.d.add_option('ethel', 'silly',\n 'female neighbor from I Love Lucy')\n n.x = Namespace(doc='x space')\n n.x.add_option('size', 100, 'how big in tons', short_form='s')\n n.x.add_option('password', 'secret', 'the password')\n return n","def test_typedef00501m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00501m/typeDef00501m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00501m/typeDef00501m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def make_key(element_name, element_type, namespace):\n # only distinguish 'element' vs other types\n if element_type in ('complexType', 'simpleType'):\n eltype = 'complexType'\n else:\n eltype = element_type\n if eltype not in ('element', 'complexType', 'simpleType'):\n raise RuntimeError(\"Unknown element type %s = %s\" % (element_name, eltype))\n return (element_name, eltype, namespace)","def test_typedef00901m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00901m/typeDef00901m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00901m/typeDef00901m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def _add_type(self, production, index, m_type):\n fully_qualified_name = None\n current_namespace = self._get_current_namespace()\n if current_namespace is not None:\n fully_qualified_name = current_namespace.fully_qualified_name()\n namespace_types = self._get_type_or_namespace_from_fully_qualified_name(fully_qualified_name)\n if m_type.name in namespace_types:\n raise ParseError(self.production_to_coord(production, index),\n \"Name '{0}' already exists\".format(m_type.fully_qualified_name()))\n namespace_types[m_type.name] = m_type","def test_typedef01202m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef01202m/typeDef01202m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef01202m/typeDef01202m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def isCountyName(elem):\r\n return (elem.attrib['k'] == \"tiger:county\")","def typeName (self, typecode):\n if typecode == qmf2.SCHEMA_DATA_VOID: return \"void\"\n elif typecode == qmf2.SCHEMA_DATA_BOOL: return \"bool\"\n elif typecode == qmf2.SCHEMA_DATA_INT: return \"int\"\n elif typecode == qmf2.SCHEMA_DATA_FLOAT: return \"float\"\n elif typecode == qmf2.SCHEMA_DATA_STRING: return \"string\"\n elif typecode == qmf2.SCHEMA_DATA_MAP: return \"map\"\n elif typecode == qmf2.SCHEMA_DATA_LIST: return \"list\"\n elif typecode == qmf2.SCHEMA_DATA_UUID: return \"uuid\"\n else:\n raise ValueError (\"Invalid type code: %s\" % str(typecode))","def element_type(self):\r\n result = conf.lib.clang_getElementType(self)\r\n if result.kind == TypeKind.INVALID:\r\n raise Exception('Element type not available on this type.')\r\n\r\n return result","def getURI(self):\n return _libsbml.ISBMLExtensionNamespaces_getURI(self)","def type(self) -> URIType:\n if self.study_instance_uid is None:\n return URIType.SERVICE\n elif self.series_instance_uid is None:\n return URIType.STUDY\n elif self.sop_instance_uid is None:\n return URIType.SERIES\n elif self.frames is None:\n return URIType.INSTANCE\n return URIType.FRAME","def exportTypes( c ) :\n assert str(type(c)) == \"<type '_mysql.connection'>\"\n xml = \"\"\n cT = sqlQuery ( c, \"select * from CrisisKind;\" )\n oT = sqlQuery ( c, \"select * from OrganizationKind;\" )\n pT = sqlQuery ( c, \"select * from PersonKind;\" ) \n for i in cT:\n xml += openTagAtt (\"CrisisKind\", \"crisisKindIdent\", i[0])\n xml += openCloseTag (\"Name\", i[1])\n xml += openCloseTag (\"Description\", i[2])\n xml += closeTag (\"CrisisKind\") \n for i in oT:\n xml += openTagAtt (\"OrganizationKind\", \"organizationKindIdent\", i[0])\n xml += openCloseTag (\"Name\", i[1])\n xml += openCloseTag (\"Description\", i[2])\n xml += closeTag (\"OrganizationKind\")\n for i in pT:\n xml += openTagAtt (\"PersonKind\", \"personKindIdent\", i[0])\n xml += openCloseTag (\"Name\", i[1])\n xml += openCloseTag (\"Description\", i[2])\n xml += closeTag (\"PersonKind\")\n assert str ( type ( xml ) ) == \"<type 'str'>\"\n return xml","def page_namespace(tree):\n root_name = ET.QName(tree.getroot().tag)\n if root_name.localname == \"PcGts\":\n return root_name.namespace\n else:\n raise ValueError(\"Not a PAGE tree\")","def SBMLNamespaces_getSBMLNamespaceURI(*args):\n return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(*args)","def _get_type_mapping():\n return {\n Box.SPACE_NAME: Box,\n Dict.SPACE_NAME: Dict,\n Discrete.SPACE_NAME: Discrete\n }","def test_typedef00201m_type_def00201m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00201m/typeDef00201m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00201m/typeDef00201m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def dnaxmlroot(dnaxmlformattype):\n if dnaxmlformattype == 'stn':\n formattext = 'Station File'\n elif dnaxmlformattype == 'msr':\n formattext = 'Measurement File'\n else:\n raise ValueError(\"ValueError: dnaxmlformattype must be either 'stn' or 'msr'\")\n NS = 'http://www.w3.org/2001/XMLSchema-instance'\n location_attribute = '{%s}noNamespaceSchemaLocation' % NS\n dnaxmlroot = ET.Element('DnaXmlFormat', attrib={location_attribute: 'DynaML.xsd'})\n dnaxmlroot.set('type', formattext)\n return dnaxmlroot","def test_typedef00301m_type_def00301m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00301m/typeDef00301m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00301m/typeDef00301m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def _from_c_repr(c_repr):\n # We create a dummy module with a global variable of the requested type,\n # parse that module, and return the type of the global variable.\n # Include stdint.h to recognize the intX_t typedefs.\n module = parse(\"\"\"\n #include <stdint.h>\n\n {} a;\n \"\"\".format(c_repr))\n return module.global_vars['a'].type","def type(name):","def test_value():\n uri = 'http://dbpedia.org/resource/California'\n values = [\n Value.from_uri(uri),\n Value.from_namespace_fragment('dbr', 'California'),\n ]\n for val in values:\n assert val.is_uri\n assert not val.is_literal\n assert val.uri == uri\n assert val.namespace == 'dbr'\n assert val.prefix == 'http://dbpedia.org/resource/'\n assert val.fragment == 'California'\n assert str(val) == val.rdf_format == f'<{uri}>'\n try:\n print(val.literal_value)\n assert False, 'should raise ValueError'\n except ValueError:\n pass\n try:\n print(val.lang)\n assert False, 'should raise ValueError'\n except ValueError:\n pass\n try:\n print(val.datatype)\n assert False, 'should raise ValueError'\n except ValueError:\n pass\n literal = '\"xyz\"@en^^<http://example.org/ns/userDatatype>'\n val = Value.from_literal(literal)\n assert val.literal_value == 'xyz'\n assert val.lang == 'en'\n assert val.datatype.rdf_format == '<http://example.org/ns/userDatatype>'\n assert val.rdf_format == literal\n literals = [\n ('false', 'boolean'),\n ('1', 'integer'),\n ('3.14', 'double'),\n ('\"hello\"', None),\n ]\n for literal, literal_type in literals:\n if literal in ('true', 'false'):\n python_literal = literal_eval(literal.title())\n else:\n python_literal = literal_eval(literal)\n print(literal, literal.title(), python_literal)\n for val in [Value.from_literal(literal), Value.from_python_literal(python_literal)]:\n assert val.literal_value == python_literal\n assert val.lang is None\n if literal_type is None:\n assert val.datatype is None\n else:\n assert val.datatype.rdf_format == f'<http://www.w3.org/2001/XMLSchema#{literal_type}>'\n assert val.rdf_format == literal","def test_typedef01301m1_positive(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef01301m/typeDef01301m1.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef01301m/typeDef01301m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def explore_expr(expr, value, is_child):\n actual_type = value.type.strip_typedefs()\n print (\"The value of '%s' is of type '%s' \"\n \"which is a typedef of type '%s'\" %\n (expr, str(value.type), str(actual_type)))\n\n Explorer.explore_expr(expr, value.cast(actual_type), is_child)\n return False","def rdf_type(self):\n return self._rdf_type","def test_typedef00403m_type_def00403m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00403m/typeDef00403m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00403m/typeDef00403m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def test_translate_resourcetypes_type_uid(self):\n self.assertEqual(\"nodes/007ff4e5-fe72-4c4b-b858-4c5f37dff946\",\n util.translate_resourcetypes(\"/nodes/007ff4e5-fe72-4c4b-b858-4c5f37dff946/\"))\n self.assertEqual(\"nodes/007ff4e5-fe72-4c4b-b858-4c5f37dff946\",\n util.translate_resourcetypes(\"/nodes/007FF4E5-FE72-4C4B-B858-4C5F37DFF946\"))","def page_namespace(tree):\n root_name = ET.QName(tree.getroot().tag)\n if root_name.localname == 'PcGts':\n return root_name.namespace\n else:\n raise ValueError('Not a PAGE tree')","def getURI(self):\n return _libsbml.SBMLNamespaces_getURI(self)","def test_typedef00401m_type_def00401m1_p(mode, save_output, output_format):\n assert_bindings(\n schema=\"sunData/ElemDecl/typeDef/typeDef00401m/typeDef00401m.xsd\",\n instance=\"sunData/ElemDecl/typeDef/typeDef00401m/typeDef00401m1_p.xml\",\n class_name=\"Root\",\n version=\"1.1\",\n mode=mode,\n save_output=save_output,\n output_format=output_format,\n structure_style=\"filenames\",\n )","def xsd_type(dtype):\n return XSD_TYPE_MAP.get(dtype,'string')"],"string":"[\n \"def XmlTypeNamespace(self) -> str:\",\n \"def is_namespace_type(self):\\n raise exceptions.NotImplementedError()\",\n \"def GetNamespaces(self):\\n return list(self.type_namespaces_map.values())\",\n \"def element_type(self) -> global___Type:\",\n \"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\\\"})\",\n \"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())\",\n \"def hasNamespaceURI(self, *args):\\n return _libsbml.XMLToken_hasNamespaceURI(self, *args)\",\n \"def GetNamespace(self, namespace_name):\\n return self.type_namespaces_map.get(namespace_name, None)\",\n \"def visit_Typedef(self, node):\\n return str_node(node)\",\n \"def test_namespaceFound(self):\\n xp = XPathQuery(\\\"/foo[@xmlns='testns']/bar\\\")\\n self.assertEqual(xp.matches(self.e), 1)\",\n \"def namespaces(self) -> NamespacesType:\\n return self.schema.namespaces\",\n \"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\",\n \"def _getTypeClass(self, namespaceURI, localName):\\r\\n bti = BaseTypeInterpreter()\\r\\n simpleTypeClass = bti.get_typeclass(localName, namespaceURI)\\r\\n return simpleTypeClass\",\n \"def XmlTypeName(self) -> str:\",\n \"def XmlNamespace(self) -> str:\",\n \"def getNamespaceURI(self, *args):\\n return _libsbml.XMLToken_getNamespaceURI(self, *args)\",\n \"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 ---------------------------------------- #\",\n \"def header_hook(header, data):\\n\\n for e in header.enums:\\n e[\\\"x_namespace\\\"] = e[\\\"namespace\\\"]\",\n \"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]\",\n \"def hasNamespaceNS(self, *args):\\n return _libsbml.XMLToken_hasNamespaceNS(self, *args)\",\n \"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\",\n \"def xmlrpc_namespace():\",\n \"def test_xml_to_dict_net_namespace(self):\\n xml = \\\"\\\"\\\"\\n <a\\n xmlns=\\\"urn:ietf:params:xml:ns:netconf:base:1.0\\\"\\n >\\n <b xmlns=\\\"something\\\">b</b>\\n <!-- Comment, ignore it -->\\n </a>\\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 )\",\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__)\",\n \"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)\",\n \"def hasURI(self, *args):\\n return _libsbml.XMLNamespaces_hasURI(self, *args)\",\n \"def getNamespace(self):\\n pass;\",\n \"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\",\n \"def namespaces(self):\\n return ()\",\n \"def getNamespace(self, parent: ghidra.program.model.symbol.Namespace, namespaceName: unicode) -> ghidra.program.model.symbol.Namespace:\\n ...\",\n \"def test_get_namespaces_names(self):\\n pass\",\n \"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\",\n \"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)\",\n \"def type(self) -> global___Type:\",\n \"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\",\n \"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 <script> element raises a warning of course.\\n assert _do_test_raw(\\\"\\\"\\\"\\n var x = \\\"foo\\\",\\n nsXUL = \\\"http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul\\\";\\n\\n x.createElementNS(nsXUL, 'script')\\n \\\"\\\"\\\").failed()\",\n \"def _fixNS(self, namespace):\\n if isinstance(namespace, bytes):\\n namespace = str(namespace, encoding=\\\"utf-8\\\")\\n\\n if namespace == OPENID_NS:\\n if self._openid_ns_uri is None:\\n raise UndefinedOpenIDNamespace('OpenID namespace not set')\\n else:\\n namespace = self._openid_ns_uri\\n\\n if namespace != BARE_NS and not isinstance(namespace, str):\\n raise TypeError(\\n \\\"Namespace must be BARE_NS, OPENID_NS or a string. got %r\\\" %\\n (namespace, ))\\n\\n if namespace != BARE_NS and ':' not in namespace:\\n fmt = 'OpenID 2.0 namespace identifiers SHOULD be URIs. Got %r'\\n warnings.warn(fmt % (namespace, ), DeprecationWarning)\\n\\n if namespace == 'sreg':\\n fmt = 'Using %r instead of \\\"sreg\\\" as namespace'\\n warnings.warn(\\n fmt % (SREG_URI, ),\\n DeprecationWarning, )\\n return SREG_URI\\n\\n return namespace\",\n \"def containsUri(self, *args):\\n return _libsbml.XMLNamespaces_containsUri(self, *args)\",\n \"def _get_element_ns(self, element):\\n\\n if (self._client == None):\\n raise ValueError('Specification is not imported yet')\\n\\n ns = None\\n for key in self._client.wsdl.schema.types.keys():\\n if (key[0] == element):\\n ns = key[1]\\n break\\n\\n return ns\",\n \"def SBMLNamespaces_isSBMLNamespace(*args):\\n return _libsbml.SBMLNamespaces_isSBMLNamespace(*args)\",\n \"def test_typedef00801m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00801m/typeDef00801m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00801m/typeDef00801m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def hasNS(self, *args):\\n return _libsbml.XMLNamespaces_hasNS(self, *args)\",\n \"def test_type_attribute(self):\\n\\n self._create_string()\\n self.assertEquals(\\\"%s:%s\\\" % (\\\"xs\\\",\\\"string\\\"), self.string.schema_node.get(\\\"type\\\"))\",\n \"def get_pyxb_namespaces():\\n return pyxb.namespace.utility.AvailableNamespaces()\",\n \"def _BuildTypeMaps(self, type_namespaces):\\n for type_namespace in type_namespaces:\\n self.type_namespaces_map[type_namespace.namespace] = type_namespace\\n for entity_type in type_namespace.valid_types_map.values():\\n if entity_type.guid:\\n if entity_type.guid in self.type_guids_map:\\n dup_guid_entry = self.type_guids_map[entity_type.guid]\\n dup_guid_type = self.GetEntityType(dup_guid_entry.namespace,\\n dup_guid_entry.typename)\\n if dup_guid_type is None:\\n raise RuntimeError('Duplicate type with guid ' + entity_type.guid\\n + ' should always be mapped')\\n entity_type.AddFinding(\\n findings_lib.DuplicateGuidsError(type_namespace.namespace,\\n entity_type, dup_guid_type))\\n dup_guid_type.AddFinding(\\n findings_lib.DuplicateGuidsError(dup_guid_entry.namespace,\\n dup_guid_type, entity_type))\\n self.type_guids_map[entity_type.guid] = EntityIdByEntry(\\n namespace=type_namespace.namespace, typename=entity_type.typename)\",\n \"def test_read_net_namespace(self):\\n pass\",\n \"def test_typedef00205m_type_def00205m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00205m/typeDef00205m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00205m/typeDef00205m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_typedef00802m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00802m/typeDef00802m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00802m/typeDef00802m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def get_type(self) -> str:\\n # Note: this name conflicts with existing python builtins\\n return self[\\\"Sns\\\"][\\\"Type\\\"]\",\n \"def pyxb_get_type_name(obj_pyxb):\\n return pyxb_get_namespace_name(obj_pyxb).split('}')[-1]\",\n \"def getTypeCode(self):\\n return _libsbml.ReplacedBy_getTypeCode(self)\",\n \"def test_typedef00202m_type_def00202m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00202m/typeDef00202m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00202m/typeDef00202m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_typedef01201m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef01201m/typeDef01201m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef01201m/typeDef01201m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def astType(cls, source):\\n if source == '':\\n return cls.BLANK\\n if source == \\\"OPENQASM 2.0;\\\":\\n return cls.DECLARATION_QASM_2_0\\n x = QTRegEx.COMMENT.search(source)\\n if x:\\n return cls.COMMENT\\n x = QTRegEx.INCLUDE.search(source)\\n if x:\\n return cls.INCLUDE\\n x = QTRegEx.CTL_2.search(source)\\n if x:\\n if x.group(1) == 'if':\\n return cls.CTL_2\\n x = QTRegEx.QREG.search(source)\\n if x:\\n return cls.QREG\\n x = QTRegEx.CREG.search(source)\\n if x:\\n return cls.CREG\\n x = QTRegEx.MEASURE.search(source)\\n if x:\\n return cls.MEASURE\\n x = QTRegEx.BARRIER.search(source)\\n if x:\\n return cls.BARRIER\\n x = QTRegEx.GATE.search(source)\\n if x:\\n return cls.GATE\\n x = QTRegEx.OP.search(source)\\n if x:\\n return cls.OP\\n return cls.UNKNOWN\",\n \"def validateOneNamespace(self, doc, elem, prefix, ns, value):\\n if doc is None: doc__o = None\\n else: doc__o = doc._o\\n if elem is None: elem__o = None\\n else: elem__o = elem._o\\n if ns is None: ns__o = None\\n else: ns__o = ns._o\\n ret = libxml2mod.xmlValidateOneNamespace(self._o, doc__o, elem__o, prefix, ns__o, value)\\n return ret\",\n \"def test_get_node_type_name(self):\\n pass\",\n \"def test_typedef00502m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00502m/typeDef00502m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00502m/typeDef00502m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_typedef00204m_type_def00204m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00204m/typeDef00204m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00204m/typeDef00204m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def SBMLNamespaces_getSupportedNamespaces():\\n return _libsbml.SBMLNamespaces_getSupportedNamespaces()\",\n \"def __generate_object_term__(self, datatype, value):\\n if datatype == NS_MGR.xsd.anyURI.rdflib:\\n term = rdflib.URIRef(value)\\n elif datatype:\\n term = rdflib.Literal(value, datatype=datatype)\\n else:\\n term = rdflib.Literal(value)\\n return term\",\n \"def XrefTypeName(typecode):\\n assert typecode in _ref_types, \\\"unknown reference type %d\\\" % typecode\\n return _ref_types[typecode]\",\n \"def getTypeCode(self):\\n return _libsbml.SBMLDocument_getTypeCode(self)\",\n \"def test_typedef00203m_type_def00203m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00203m/typeDef00203m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00203m/typeDef00203m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def _BuildNamespaceFolderMap(self, type_folders):\\n for folder in type_folders:\\n self.namespace_folder_map[folder.local_namespace.namespace] = folder\",\n \"def setOpenIDNamespace(self, openid_ns_uri, implicit):\\n if isinstance(openid_ns_uri, bytes):\\n openid_ns_uri = str(openid_ns_uri, encoding=\\\"utf-8\\\")\\n if openid_ns_uri not in self.allowed_openid_namespaces:\\n raise InvalidOpenIDNamespace(openid_ns_uri)\\n\\n self.namespaces.addAlias(openid_ns_uri, NULL_NAMESPACE, implicit)\\n self._openid_ns_uri = openid_ns_uri\",\n \"def explore_type(name, datatype, is_child):\\n actual_type = datatype.strip_typedefs()\\n if is_child:\\n print (\\\"The type of %s is a typedef of type '%s'.\\\" %\\n (name, str(actual_type)))\\n else:\\n print (\\\"The type '%s' is a typedef of type '%s'.\\\" %\\n (name, str(actual_type)))\\n\\n Explorer.explore_type(name, actual_type, is_child)\\n return False\",\n \"def getTypeCode(self):\\n return _libsbml.ReplacedElement_getTypeCode(self)\",\n \"def get_type_label(type_url):\\n return type_dict[type_url]\",\n \"def _cim_scope_code_type():\\n return {\\n 'name' : 'cim_scope_code_type',\\n 'is_open' : False,\\n 'doc' : 'This would cover quality issues with the CIM itself',\\n 'members' : [\\n ('dataset', None),\\n ('software', None),\\n ('service', None),\\n ('model', None),\\n ('modelComponent', None),\\n ('simulation', None),\\n ('experiment', None),\\n ('numericalRequirement', None),\\n ('ensemble', None),\\n ('file', None),\\n ],\\n }\",\n \"def test_typedef00402m_type_def00402m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00402m/typeDef00402m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00402m/typeDef00402m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def _some_namespaces(self):\\n n = Namespace(doc='top')\\n n.add_option('aaa', '2011-05-04T15:10:00', 'the a',\\n short_form='a',\\n from_string_converter=dtu.datetime_from_ISO_string\\n )\\n n.c = Namespace(doc='c space')\\n n.c.add_option('fred', 'stupid', 'husband from Flintstones')\\n n.c.add_option('wilma', 'waspish', 'wife from Flintstones')\\n n.c.e = Namespace(doc='e space')\\n n.c.e.add_option('dwight',\\n default=97,\\n doc='my uncle')\\n n.c.add_option('dwight',\\n default=98,\\n doc='your uncle')\\n n.d = Namespace(doc='d space')\\n n.d.add_option('fred', 'crabby', 'male neighbor from I Love Lucy')\\n n.d.add_option('ethel', 'silly',\\n 'female neighbor from I Love Lucy')\\n n.x = Namespace(doc='x space')\\n n.x.add_option('size', 100, 'how big in tons', short_form='s')\\n n.x.add_option('password', 'secret', 'the password')\\n return n\",\n \"def test_typedef00501m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00501m/typeDef00501m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00501m/typeDef00501m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def make_key(element_name, element_type, namespace):\\n # only distinguish 'element' vs other types\\n if element_type in ('complexType', 'simpleType'):\\n eltype = 'complexType'\\n else:\\n eltype = element_type\\n if eltype not in ('element', 'complexType', 'simpleType'):\\n raise RuntimeError(\\\"Unknown element type %s = %s\\\" % (element_name, eltype))\\n return (element_name, eltype, namespace)\",\n \"def test_typedef00901m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00901m/typeDef00901m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00901m/typeDef00901m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def _add_type(self, production, index, m_type):\\n fully_qualified_name = None\\n current_namespace = self._get_current_namespace()\\n if current_namespace is not None:\\n fully_qualified_name = current_namespace.fully_qualified_name()\\n namespace_types = self._get_type_or_namespace_from_fully_qualified_name(fully_qualified_name)\\n if m_type.name in namespace_types:\\n raise ParseError(self.production_to_coord(production, index),\\n \\\"Name '{0}' already exists\\\".format(m_type.fully_qualified_name()))\\n namespace_types[m_type.name] = m_type\",\n \"def test_typedef01202m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef01202m/typeDef01202m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef01202m/typeDef01202m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def isCountyName(elem):\\r\\n return (elem.attrib['k'] == \\\"tiger:county\\\")\",\n \"def typeName (self, typecode):\\n if typecode == qmf2.SCHEMA_DATA_VOID: return \\\"void\\\"\\n elif typecode == qmf2.SCHEMA_DATA_BOOL: return \\\"bool\\\"\\n elif typecode == qmf2.SCHEMA_DATA_INT: return \\\"int\\\"\\n elif typecode == qmf2.SCHEMA_DATA_FLOAT: return \\\"float\\\"\\n elif typecode == qmf2.SCHEMA_DATA_STRING: return \\\"string\\\"\\n elif typecode == qmf2.SCHEMA_DATA_MAP: return \\\"map\\\"\\n elif typecode == qmf2.SCHEMA_DATA_LIST: return \\\"list\\\"\\n elif typecode == qmf2.SCHEMA_DATA_UUID: return \\\"uuid\\\"\\n else:\\n raise ValueError (\\\"Invalid type code: %s\\\" % str(typecode))\",\n \"def element_type(self):\\r\\n result = conf.lib.clang_getElementType(self)\\r\\n if result.kind == TypeKind.INVALID:\\r\\n raise Exception('Element type not available on this type.')\\r\\n\\r\\n return result\",\n \"def getURI(self):\\n return _libsbml.ISBMLExtensionNamespaces_getURI(self)\",\n \"def type(self) -> URIType:\\n if self.study_instance_uid is None:\\n return URIType.SERVICE\\n elif self.series_instance_uid is None:\\n return URIType.STUDY\\n elif self.sop_instance_uid is None:\\n return URIType.SERIES\\n elif self.frames is None:\\n return URIType.INSTANCE\\n return URIType.FRAME\",\n \"def exportTypes( c ) :\\n assert str(type(c)) == \\\"<type '_mysql.connection'>\\\"\\n xml = \\\"\\\"\\n cT = sqlQuery ( c, \\\"select * from CrisisKind;\\\" )\\n oT = sqlQuery ( c, \\\"select * from OrganizationKind;\\\" )\\n pT = sqlQuery ( c, \\\"select * from PersonKind;\\\" ) \\n for i in cT:\\n xml += openTagAtt (\\\"CrisisKind\\\", \\\"crisisKindIdent\\\", i[0])\\n xml += openCloseTag (\\\"Name\\\", i[1])\\n xml += openCloseTag (\\\"Description\\\", i[2])\\n xml += closeTag (\\\"CrisisKind\\\") \\n for i in oT:\\n xml += openTagAtt (\\\"OrganizationKind\\\", \\\"organizationKindIdent\\\", i[0])\\n xml += openCloseTag (\\\"Name\\\", i[1])\\n xml += openCloseTag (\\\"Description\\\", i[2])\\n xml += closeTag (\\\"OrganizationKind\\\")\\n for i in pT:\\n xml += openTagAtt (\\\"PersonKind\\\", \\\"personKindIdent\\\", i[0])\\n xml += openCloseTag (\\\"Name\\\", i[1])\\n xml += openCloseTag (\\\"Description\\\", i[2])\\n xml += closeTag (\\\"PersonKind\\\")\\n assert str ( type ( xml ) ) == \\\"<type 'str'>\\\"\\n return xml\",\n \"def page_namespace(tree):\\n root_name = ET.QName(tree.getroot().tag)\\n if root_name.localname == \\\"PcGts\\\":\\n return root_name.namespace\\n else:\\n raise ValueError(\\\"Not a PAGE tree\\\")\",\n \"def SBMLNamespaces_getSBMLNamespaceURI(*args):\\n return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(*args)\",\n \"def _get_type_mapping():\\n return {\\n Box.SPACE_NAME: Box,\\n Dict.SPACE_NAME: Dict,\\n Discrete.SPACE_NAME: Discrete\\n }\",\n \"def test_typedef00201m_type_def00201m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00201m/typeDef00201m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00201m/typeDef00201m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def dnaxmlroot(dnaxmlformattype):\\n if dnaxmlformattype == 'stn':\\n formattext = 'Station File'\\n elif dnaxmlformattype == 'msr':\\n formattext = 'Measurement File'\\n else:\\n raise ValueError(\\\"ValueError: dnaxmlformattype must be either 'stn' or 'msr'\\\")\\n NS = 'http://www.w3.org/2001/XMLSchema-instance'\\n location_attribute = '{%s}noNamespaceSchemaLocation' % NS\\n dnaxmlroot = ET.Element('DnaXmlFormat', attrib={location_attribute: 'DynaML.xsd'})\\n dnaxmlroot.set('type', formattext)\\n return dnaxmlroot\",\n \"def test_typedef00301m_type_def00301m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00301m/typeDef00301m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00301m/typeDef00301m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def _from_c_repr(c_repr):\\n # We create a dummy module with a global variable of the requested type,\\n # parse that module, and return the type of the global variable.\\n # Include stdint.h to recognize the intX_t typedefs.\\n module = parse(\\\"\\\"\\\"\\n #include <stdint.h>\\n\\n {} a;\\n \\\"\\\"\\\".format(c_repr))\\n return module.global_vars['a'].type\",\n \"def type(name):\",\n \"def test_value():\\n uri = 'http://dbpedia.org/resource/California'\\n values = [\\n Value.from_uri(uri),\\n Value.from_namespace_fragment('dbr', 'California'),\\n ]\\n for val in values:\\n assert val.is_uri\\n assert not val.is_literal\\n assert val.uri == uri\\n assert val.namespace == 'dbr'\\n assert val.prefix == 'http://dbpedia.org/resource/'\\n assert val.fragment == 'California'\\n assert str(val) == val.rdf_format == f'<{uri}>'\\n try:\\n print(val.literal_value)\\n assert False, 'should raise ValueError'\\n except ValueError:\\n pass\\n try:\\n print(val.lang)\\n assert False, 'should raise ValueError'\\n except ValueError:\\n pass\\n try:\\n print(val.datatype)\\n assert False, 'should raise ValueError'\\n except ValueError:\\n pass\\n literal = '\\\"xyz\\\"@en^^<http://example.org/ns/userDatatype>'\\n val = Value.from_literal(literal)\\n assert val.literal_value == 'xyz'\\n assert val.lang == 'en'\\n assert val.datatype.rdf_format == '<http://example.org/ns/userDatatype>'\\n assert val.rdf_format == literal\\n literals = [\\n ('false', 'boolean'),\\n ('1', 'integer'),\\n ('3.14', 'double'),\\n ('\\\"hello\\\"', None),\\n ]\\n for literal, literal_type in literals:\\n if literal in ('true', 'false'):\\n python_literal = literal_eval(literal.title())\\n else:\\n python_literal = literal_eval(literal)\\n print(literal, literal.title(), python_literal)\\n for val in [Value.from_literal(literal), Value.from_python_literal(python_literal)]:\\n assert val.literal_value == python_literal\\n assert val.lang is None\\n if literal_type is None:\\n assert val.datatype is None\\n else:\\n assert val.datatype.rdf_format == f'<http://www.w3.org/2001/XMLSchema#{literal_type}>'\\n assert val.rdf_format == literal\",\n \"def test_typedef01301m1_positive(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef01301m/typeDef01301m1.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef01301m/typeDef01301m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def explore_expr(expr, value, is_child):\\n actual_type = value.type.strip_typedefs()\\n print (\\\"The value of '%s' is of type '%s' \\\"\\n \\\"which is a typedef of type '%s'\\\" %\\n (expr, str(value.type), str(actual_type)))\\n\\n Explorer.explore_expr(expr, value.cast(actual_type), is_child)\\n return False\",\n \"def rdf_type(self):\\n return self._rdf_type\",\n \"def test_typedef00403m_type_def00403m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00403m/typeDef00403m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00403m/typeDef00403m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def test_translate_resourcetypes_type_uid(self):\\n self.assertEqual(\\\"nodes/007ff4e5-fe72-4c4b-b858-4c5f37dff946\\\",\\n util.translate_resourcetypes(\\\"/nodes/007ff4e5-fe72-4c4b-b858-4c5f37dff946/\\\"))\\n self.assertEqual(\\\"nodes/007ff4e5-fe72-4c4b-b858-4c5f37dff946\\\",\\n util.translate_resourcetypes(\\\"/nodes/007FF4E5-FE72-4C4B-B858-4C5F37DFF946\\\"))\",\n \"def page_namespace(tree):\\n root_name = ET.QName(tree.getroot().tag)\\n if root_name.localname == 'PcGts':\\n return root_name.namespace\\n else:\\n raise ValueError('Not a PAGE tree')\",\n \"def getURI(self):\\n return _libsbml.SBMLNamespaces_getURI(self)\",\n \"def test_typedef00401m_type_def00401m1_p(mode, save_output, output_format):\\n assert_bindings(\\n schema=\\\"sunData/ElemDecl/typeDef/typeDef00401m/typeDef00401m.xsd\\\",\\n instance=\\\"sunData/ElemDecl/typeDef/typeDef00401m/typeDef00401m1_p.xml\\\",\\n class_name=\\\"Root\\\",\\n version=\\\"1.1\\\",\\n mode=mode,\\n save_output=save_output,\\n output_format=output_format,\\n structure_style=\\\"filenames\\\",\\n )\",\n \"def xsd_type(dtype):\\n return XSD_TYPE_MAP.get(dtype,'string')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66442066","0.5593534","0.5443724","0.5412149","0.5365882","0.5329653","0.5311929","0.5237586","0.5178215","0.5165827","0.5055696","0.5044016","0.5007665","0.4926739","0.48959085","0.48641986","0.48631665","0.4855509","0.48434836","0.48183277","0.4792356","0.47862798","0.47404408","0.47294393","0.4723793","0.47111255","0.4702394","0.46919808","0.46903983","0.46584937","0.46271244","0.46186867","0.4617531","0.4604043","0.45993757","0.45985585","0.4591038","0.4586497","0.45848095","0.45825526","0.45807338","0.4573924","0.45574927","0.45526972","0.45472842","0.45332465","0.4530956","0.45251143","0.45243555","0.45225555","0.45212564","0.45162475","0.45096263","0.44960347","0.4493138","0.44918758","0.44866842","0.44828385","0.44737914","0.4473183","0.4472023","0.44692904","0.44670665","0.44466957","0.44392848","0.44391468","0.44376433","0.4437629","0.44349527","0.44334894","0.4433334","0.44330135","0.44300586","0.44294038","0.44290915","0.44268504","0.442076","0.4419924","0.4417466","0.44173992","0.43981576","0.4397718","0.43933913","0.43869466","0.4383478","0.43826568","0.43791485","0.4378129","0.43760198","0.43731675","0.43726635","0.43709844","0.43701172","0.43693835","0.4368849","0.43682677","0.43614888","0.43580577","0.43551713","0.43525833"],"string":"[\n \"0.66442066\",\n \"0.5593534\",\n \"0.5443724\",\n \"0.5412149\",\n \"0.5365882\",\n \"0.5329653\",\n \"0.5311929\",\n \"0.5237586\",\n \"0.5178215\",\n \"0.5165827\",\n \"0.5055696\",\n \"0.5044016\",\n \"0.5007665\",\n \"0.4926739\",\n \"0.48959085\",\n \"0.48641986\",\n \"0.48631665\",\n \"0.4855509\",\n \"0.48434836\",\n \"0.48183277\",\n \"0.4792356\",\n \"0.47862798\",\n \"0.47404408\",\n \"0.47294393\",\n \"0.4723793\",\n \"0.47111255\",\n \"0.4702394\",\n \"0.46919808\",\n \"0.46903983\",\n \"0.46584937\",\n \"0.46271244\",\n \"0.46186867\",\n \"0.4617531\",\n \"0.4604043\",\n \"0.45993757\",\n \"0.45985585\",\n \"0.4591038\",\n \"0.4586497\",\n \"0.45848095\",\n \"0.45825526\",\n \"0.45807338\",\n \"0.4573924\",\n \"0.45574927\",\n \"0.45526972\",\n \"0.45472842\",\n \"0.45332465\",\n \"0.4530956\",\n \"0.45251143\",\n \"0.45243555\",\n \"0.45225555\",\n \"0.45212564\",\n \"0.45162475\",\n \"0.45096263\",\n \"0.44960347\",\n \"0.4493138\",\n \"0.44918758\",\n \"0.44866842\",\n \"0.44828385\",\n \"0.44737914\",\n \"0.4473183\",\n \"0.4472023\",\n \"0.44692904\",\n \"0.44670665\",\n \"0.44466957\",\n \"0.44392848\",\n \"0.44391468\",\n \"0.44376433\",\n \"0.4437629\",\n \"0.44349527\",\n \"0.44334894\",\n \"0.4433334\",\n \"0.44330135\",\n \"0.44300586\",\n \"0.44294038\",\n \"0.44290915\",\n \"0.44268504\",\n \"0.442076\",\n \"0.4419924\",\n \"0.4417466\",\n \"0.44173992\",\n \"0.43981576\",\n \"0.4397718\",\n \"0.43933913\",\n \"0.43869466\",\n \"0.4383478\",\n \"0.43826568\",\n \"0.43791485\",\n \"0.4378129\",\n \"0.43760198\",\n \"0.43731675\",\n \"0.43726635\",\n \"0.43709844\",\n \"0.43701172\",\n \"0.43693835\",\n \"0.4368849\",\n \"0.43682677\",\n \"0.43614888\",\n \"0.43580577\",\n \"0.43551713\",\n \"0.43525833\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6797826"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":1699,"cells":{"query":{"kind":"string","value":"Retrieves a prefix/namespace mapping. namespaceURI namespace"},"document":{"kind":"string","value":"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"},"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 prefix_to_ns(self, prefix):\n defin = self.module.i_ctx.get_module(\n self.module.i_prefixes[prefix][0])\n return defin.search_one(\"namespace\").arg","def get_namespace(self, prefix):\n try:\n return self.parser.namespaces[prefix]\n except KeyError as err:\n raise self.error('FONS0004', 'No namespace found for prefix %s' % str(err))","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 getNamespacePrefix(self, namespace):\n return self.namespaceTable.get(namespace, None)","def ns_prefix_dict(g):\n return {ns: prefix.toPython() for (ns, prefix) in g.namespaces()}","def prefixForNamespace (self, namespace):\n pfxs = self.__inScopePrefixes.get(namespace)\n if pfxs:\n return next(iter(pfxs))\n return None","def getNamespacePrefixDict(xmlString):\n \n nss = {} \n defCnt = 0\n matches = re.findall(r'\\s+xmlns:?(\\w*?)\\s*=\\s*[\\'\"](.*?)[\\'\"]', xmlString)\n for match in matches:\n prefix = match[0]; ns = match[1]\n if prefix == '':\n defCnt += 1\n prefix = '_' * defCnt\n nss[prefix] = ns\n return nss","def getPrefix(self, *args):\n return _libsbml.XMLNamespaces_getPrefix(self, *args)","def getNamespacePrefix(self, *args):\n return _libsbml.XMLToken_getNamespacePrefix(self, *args)","def namespace_map(self, target):\n self._check_target(target)\n return target.namespace_map or self._default_namespace_map","def namespaces(self):\n return [self._namespace_prefix]","def from_ns(match):\n return ns.get(match.group(1), match.group())","def GetNamespace(self, namespace_name):\n return self.type_namespaces_map.get(namespace_name, None)","def _get_prefixes(self):\n return self._dispatch_json(\"get\", self._db_base(\"prefixes\")).get(\"@context\")","def namespace(self):\n return VarLookupDict(self._namespaces)","def get_prefixes(context: str = \"go\"):\n context = load_context(context)\n extended_prefix_map = context.as_extended_prefix_map()\n converter = Converter.from_extended_prefix_map(extended_prefix_map)\n cmaps = converter.prefix_map\n # hacky solution to: https://github.com/geneontology/go-site/issues/2000\n cmap_remapped = remap_prefixes(cmaps)\n\n return cmap_remapped","def get_namespace(self, namespace, lowercase=True, trim_namespace=True):\n\t\treturn self.get_namespace_view(namespace, lowercase, trim_namespace).copy()","def getNamespaceIndexByPrefix(self, *args):\n return _libsbml.XMLToken_getNamespaceIndexByPrefix(self, *args)","def xpathNsLookup(self, prefix):\n ret = libxml2mod.xmlXPathNsLookup(self._o, prefix)\n return ret","def namespace(self, namespace):\n return self.client.call('GET',\n self.name, params={'namespace': namespace})","def _getnamespaces(cls):\n return \" \".join(Kmlable._namespaces)","def SBMLNamespaces_getSBMLNamespaceURI(*args):\n return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(*args)","def getNamespaces(self, *args):\n return _libsbml.SBMLNamespaces_getNamespaces(self, *args)","def getIndexByPrefix(self, *args):\n return _libsbml.XMLNamespaces_getIndexByPrefix(self, *args)","def LookupNamespace(self, prefix):\n ret = libxml2mod.xmlTextReaderLookupNamespace(self._o, prefix)\n return ret","def namespace(self):\n return self.__key.namespace()","def qname_to_prefixed(qname, namespaces):\n if not qname:\n return qname\n\n namespace = get_namespace(qname)\n for prefix, uri in sorted(filter(lambda x: x[1] == namespace, namespaces.items()), reverse=True):\n if not uri:\n return '%s:%s' % (prefix, qname) if prefix else qname\n elif prefix:\n return qname.replace('{%s}' % uri, '%s:' % prefix)\n else:\n return qname.replace('{%s}' % uri, '')\n else:\n return qname","def namespaces(self, psuedo=True):\n if self._namespaces == None:\n result = self.call({'action': 'query',\n 'meta': 'siteinfo',\n 'siprop': 'namespaces'})\n self._namespaces = {}\n self._psuedo_namespaces = {}\n for nsid in result['query']['namespaces']:\n if int(nsid) >= 0:\n self._namespaces[int(nsid)] = \\\n result['query']['namespaces'][nsid]['*']\n else:\n self._psuedo_namespaces[int(nsid)] = \\\n result['query']['namespaces'][nsid]['*']\n if psuedo:\n retval = {}\n retval.update(self._namespaces)\n retval.update(self._psuedo_namespaces)\n return retval\n else:\n return self._namespaces","def get_ns_dict(xml):\n \n nss = {} \n def_cnt = 0\n matches = re.findall(r'\\s+xmlns:?(\\w*?)\\s*=\\s*[\\'\"](.*?)[\\'\"]', xml)\n for match in matches:\n prefix = match[0]; ns = match[1]\n if prefix == '':\n def_cnt += 1\n prefix = '_' * def_cnt\n nss[prefix] = ns\n return nss","def prefixes(self):\n # a new OntCuries-like object that wraps NamespaceManager\n # and can leverage its trie\n self.namespace_manager\n raise NotImplementedError('yet')","def getSBMLNamespaceURI(*args):\n return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(*args)","def test_get_namespaces_names(self):\n pass","def _index_and_mapping(self, namespace):\n index, doc_type = namespace.split('.', 1)\n return index.lower(), doc_type","def address_space_prefixes(self) -> pulumi.Output[Sequence[str]]:\n return pulumi.get(self, \"address_space_prefixes\")","def getNamespaceURI(self, *args):\n return _libsbml.XMLToken_getNamespaceURI(self, *args)","def get_namespaces(self, label_selector=None):\n return self.core_client.list_namespace(label_selector=label_selector)","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 get_namespace(self) -> str:\n return self._namespace","def getNamespaces(self):\n return _libsbml.SBase_getNamespaces(self)","def declareNamespace (self, namespace, prefix=None, add_to_map=False):\n if not isinstance(namespace, pyxb.namespace.Namespace):\n raise pyxb.UsageError('declareNamespace: must be given a namespace instance')\n if namespace.isAbsentNamespace():\n raise pyxb.UsageError('declareNamespace: namespace must not be an absent namespace')\n if prefix is None:\n prefix = namespace.prefix()\n if prefix is None:\n pfxs = self.__inScopePrefixes.get(namespace)\n if pfxs:\n prefix = next(iter(pfxs))\n while prefix is None:\n self.__namespacePrefixCounter += 1\n candidate_prefix = 'ns%d' % (self.__namespacePrefixCounter,)\n if not (candidate_prefix in self.__inScopeNamespaces):\n prefix = candidate_prefix\n ns = self.__inScopePrefixes.get(prefix)\n if ns:\n if ns != namespace:\n raise pyxb.LogicError('Prefix %s is already in use for %s' % (prefix, ns))\n return prefix\n if not self.__mutableInScopeNamespaces:\n self.__clonePrefixMap()\n self.__mutableInScopeNamespaces = True\n self.__addPrefixMap(prefix, namespace)\n return prefix","def get_namespace(key):\n\tif key not in REGISTRY:\n\t\traise KeyError(\"key:{0} does not exist\".format(key))\n\n\treturn REGISTRY[key]","def _get_xpath_namespaces(self, namespaces: Optional[NamespacesType] = None) \\\n -> Dict[str, str]:\n if namespaces is None:\n namespaces = {k: v for k, v in self.namespaces.items() if k}\n namespaces[''] = self.xpath_default_namespace\n elif '' not in namespaces:\n namespaces[''] = self.xpath_default_namespace\n\n xpath_namespaces: Dict[str, str] = XPath2Parser.DEFAULT_NAMESPACES.copy()\n xpath_namespaces.update(namespaces)\n return xpath_namespaces","def _getPrefixDict(self):\r\n if not hasattr(self, '_prefixDict'):\r\n self.__prefixDict = {}\r\n return self.__prefixDict","def GetNamespaces(self):\n return list(self.type_namespaces_map.values())","def namespace(self) -> str:\n return pulumi.get(self, \"namespace\")","def getIndex(self, *args):\n return _libsbml.XMLNamespaces_getIndex(self, *args)","def namespace(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"namespace\")","def test_get_namespace(self):\n pass","def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"namespaces\")","def namespace(self):\n return self._namespace","def namespace(self):\n assert self._namespace\n return self._namespace","def namespace_to_dict(n):\n assert isinstance(n, SimpleNamespace)\n return _namespace_to_dict_util(n)","def _DefaultNamespace():\n return namespace_manager.get_namespace()","def _get_xml_namespace(root_tag):\n m = re.match(r\"\\{.*\\}\", root_tag)\n return m.group(0) if m else \"\"","def get_identifiers_org_namespace(prefix):\n try:\n return get_identifiers_org_namespaces()[prefix]\n except KeyError:\n raise InvalidIdentifiersOrgUri('`{}` is not a valid prefix of a Identifiers.org namespace.'.format(prefix))","def prefixed_to_qname(name, namespaces):\n if not name or name[0] == '{':\n return name\n\n try:\n prefix, name = name.split(':')\n except ValueError:\n if ':' in name:\n raise XMLSchemaValueError(\"wrong format for reference name %r\" % name)\n try:\n uri = namespaces['']\n except KeyError:\n return name\n else:\n return '{%s}%s' % (uri, name) if uri else name\n else:\n if not prefix or not name:\n raise XMLSchemaValueError(\"wrong format for reference name %r\" % name)\n try:\n uri = namespaces[prefix]\n except KeyError:\n raise XMLSchemaValueError(\"prefix %r not found in namespace map\" % prefix)\n else:\n return '{%s}%s' % (uri, name) if uri else name","def _load_namespaces(self):\n nsdocs = self._docset.get_namespaces()\n for nsdoc in nsdocs:\n nsobj = Namespace(nsdoc)\n self._docmap[nsdoc] = nsobj\n self._namespaces.add(nsobj)","def get_uri_prefix() -> str:\n Config.__get()\n assert Config.__config is not None\n return Config.__config.get(\"wsgi\", \"uri_prefix\").strip()","def getURI(self, *args):\n return _libsbml.XMLNamespaces_getURI(self, *args)","def getNamespace(self):\n pass;","def get_constants(prefix):\n return dict( (getattr(socket, n), n)\n for n in dir(socket)\n if n.startswith(prefix)\n )","def namespace(self) -> Optional[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> Optional[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> Optional[str]:\n return pulumi.get(self, \"namespace\")","def _load_namespaces(self, result):\n self._namespaces = {}\n\n for namespace in result[\"query\"][\"namespaces\"].values():\n ns_id = namespace[\"id\"]\n name = namespace[\"*\"]\n try:\n canonical = namespace[\"canonical\"]\n except KeyError:\n self._namespaces[ns_id] = [name]\n else:\n if name != canonical:\n self._namespaces[ns_id] = [name, canonical]\n else:\n self._namespaces[ns_id] = [name]\n\n for namespace in result[\"query\"][\"namespacealiases\"]:\n ns_id = namespace[\"id\"]\n alias = namespace[\"*\"]\n self._namespaces[ns_id].append(alias)","def namespaces(self):\n if not self._namespaces:\n self.update_namespaces_info()\n\n return self._namespaces","def get(self, *args):\n return _libsbml.ListWrapperSBMLNamespaces_get(self, *args)","def namespace(self) -> str:\n return self._namespace","def get_namespaces():\r\n\r\n print 'Getting namespaces'\r\n tree = etree.parse('http://lesswrong.wikia.com/wiki/Special:AllPages', parser)\r\n options = tree.xpath('//select[@id=\"namespace\"]/option')\r\n namespaces = [option.get('value') for option in options]\r\n pprint(namespaces)\r\n return namespaces","def getPrefix(self):\n return _libsbml.XMLTriple_getPrefix(self)","def get_prefixes(buildout):\n\n prefixes = parse_list(buildout.get('prefixes', ''))\n return [os.path.abspath(k) for k in prefixes if os.path.exists(k)]","def remap_prefixes(cmap):\n cmap[\"MGI\"] = \"http://identifiers.org/mgi/MGI:\"\n cmap[\"WB\"] = \"http://identifiers.org/wormbase/\"\n return cmap","def getNamespaces(self):\n return _libsbml.SBMLDocument_getNamespaces(self)","def namespaces(self) -> NamespacesType:\n return self.schema.namespaces","def getNamespaces(self):\n return _libsbml.XMLToken_getNamespaces(self)","def namespace (self) :\n\n return self.__namespace__","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def namespace(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"namespace\")","def getURI(self):\n return _libsbml.SBMLNamespaces_getURI(self)","def prefix(self):\n return self[\"prefix\"]","def prefix(self):\n return self[\"prefix\"]","def xmlrpc_namespace():","def _get_namespace(self, data):\n ns_name = data['filename'].namespace\n try:\n return models.Namespace.objects.get(name=ns_name)\n except models.Namespace.DoesNotExist:\n raise exceptions.ValidationError(\n f'Namespace \"{ns_name}\" does not exist.'\n )","def getPrefix(self):\n return _libsbml.SBase_getPrefix(self)","def getPrefix(self):\n raise NotImplementedError","def getNamespaceIndex(self, *args):\n return _libsbml.XMLToken_getNamespaceIndex(self, *args)","def namespace(self, namespace, lowercase=True, trim_namespace=True):\n\t\treturn Config(\n\t\t\t\tself.root_path,\n\t\t\t\tself.get_namespace_view(namespace, lowercase, trim_namespace)\n\t\t\t)","def get_constants(prefix):\n return {\n getattr(socket, n): n\n for n in dir(socket)\n if n.startswith(prefix)\n }"],"string":"[\n \"def prefix_to_ns(self, prefix):\\n defin = self.module.i_ctx.get_module(\\n self.module.i_prefixes[prefix][0])\\n return defin.search_one(\\\"namespace\\\").arg\",\n \"def get_namespace(self, prefix):\\n try:\\n return self.parser.namespaces[prefix]\\n except KeyError as err:\\n raise self.error('FONS0004', 'No namespace found for prefix %s' % str(err))\",\n \"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]\",\n \"def getNamespacePrefix(self, namespace):\\n return self.namespaceTable.get(namespace, None)\",\n \"def ns_prefix_dict(g):\\n return {ns: prefix.toPython() for (ns, prefix) in g.namespaces()}\",\n \"def prefixForNamespace (self, namespace):\\n pfxs = self.__inScopePrefixes.get(namespace)\\n if pfxs:\\n return next(iter(pfxs))\\n return None\",\n \"def getNamespacePrefixDict(xmlString):\\n \\n nss = {} \\n defCnt = 0\\n matches = re.findall(r'\\\\s+xmlns:?(\\\\w*?)\\\\s*=\\\\s*[\\\\'\\\"](.*?)[\\\\'\\\"]', xmlString)\\n for match in matches:\\n prefix = match[0]; ns = match[1]\\n if prefix == '':\\n defCnt += 1\\n prefix = '_' * defCnt\\n nss[prefix] = ns\\n return nss\",\n \"def getPrefix(self, *args):\\n return _libsbml.XMLNamespaces_getPrefix(self, *args)\",\n \"def getNamespacePrefix(self, *args):\\n return _libsbml.XMLToken_getNamespacePrefix(self, *args)\",\n \"def namespace_map(self, target):\\n self._check_target(target)\\n return target.namespace_map or self._default_namespace_map\",\n \"def namespaces(self):\\n return [self._namespace_prefix]\",\n \"def from_ns(match):\\n return ns.get(match.group(1), match.group())\",\n \"def GetNamespace(self, namespace_name):\\n return self.type_namespaces_map.get(namespace_name, None)\",\n \"def _get_prefixes(self):\\n return self._dispatch_json(\\\"get\\\", self._db_base(\\\"prefixes\\\")).get(\\\"@context\\\")\",\n \"def namespace(self):\\n return VarLookupDict(self._namespaces)\",\n \"def get_prefixes(context: str = \\\"go\\\"):\\n context = load_context(context)\\n extended_prefix_map = context.as_extended_prefix_map()\\n converter = Converter.from_extended_prefix_map(extended_prefix_map)\\n cmaps = converter.prefix_map\\n # hacky solution to: https://github.com/geneontology/go-site/issues/2000\\n cmap_remapped = remap_prefixes(cmaps)\\n\\n return cmap_remapped\",\n \"def get_namespace(self, namespace, lowercase=True, trim_namespace=True):\\n\\t\\treturn self.get_namespace_view(namespace, lowercase, trim_namespace).copy()\",\n \"def getNamespaceIndexByPrefix(self, *args):\\n return _libsbml.XMLToken_getNamespaceIndexByPrefix(self, *args)\",\n \"def xpathNsLookup(self, prefix):\\n ret = libxml2mod.xmlXPathNsLookup(self._o, prefix)\\n return ret\",\n \"def namespace(self, namespace):\\n return self.client.call('GET',\\n self.name, params={'namespace': namespace})\",\n \"def _getnamespaces(cls):\\n return \\\" \\\".join(Kmlable._namespaces)\",\n \"def SBMLNamespaces_getSBMLNamespaceURI(*args):\\n return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(*args)\",\n \"def getNamespaces(self, *args):\\n return _libsbml.SBMLNamespaces_getNamespaces(self, *args)\",\n \"def getIndexByPrefix(self, *args):\\n return _libsbml.XMLNamespaces_getIndexByPrefix(self, *args)\",\n \"def LookupNamespace(self, prefix):\\n ret = libxml2mod.xmlTextReaderLookupNamespace(self._o, prefix)\\n return ret\",\n \"def namespace(self):\\n return self.__key.namespace()\",\n \"def qname_to_prefixed(qname, namespaces):\\n if not qname:\\n return qname\\n\\n namespace = get_namespace(qname)\\n for prefix, uri in sorted(filter(lambda x: x[1] == namespace, namespaces.items()), reverse=True):\\n if not uri:\\n return '%s:%s' % (prefix, qname) if prefix else qname\\n elif prefix:\\n return qname.replace('{%s}' % uri, '%s:' % prefix)\\n else:\\n return qname.replace('{%s}' % uri, '')\\n else:\\n return qname\",\n \"def namespaces(self, psuedo=True):\\n if self._namespaces == None:\\n result = self.call({'action': 'query',\\n 'meta': 'siteinfo',\\n 'siprop': 'namespaces'})\\n self._namespaces = {}\\n self._psuedo_namespaces = {}\\n for nsid in result['query']['namespaces']:\\n if int(nsid) >= 0:\\n self._namespaces[int(nsid)] = \\\\\\n result['query']['namespaces'][nsid]['*']\\n else:\\n self._psuedo_namespaces[int(nsid)] = \\\\\\n result['query']['namespaces'][nsid]['*']\\n if psuedo:\\n retval = {}\\n retval.update(self._namespaces)\\n retval.update(self._psuedo_namespaces)\\n return retval\\n else:\\n return self._namespaces\",\n \"def get_ns_dict(xml):\\n \\n nss = {} \\n def_cnt = 0\\n matches = re.findall(r'\\\\s+xmlns:?(\\\\w*?)\\\\s*=\\\\s*[\\\\'\\\"](.*?)[\\\\'\\\"]', xml)\\n for match in matches:\\n prefix = match[0]; ns = match[1]\\n if prefix == '':\\n def_cnt += 1\\n prefix = '_' * def_cnt\\n nss[prefix] = ns\\n return nss\",\n \"def prefixes(self):\\n # a new OntCuries-like object that wraps NamespaceManager\\n # and can leverage its trie\\n self.namespace_manager\\n raise NotImplementedError('yet')\",\n \"def getSBMLNamespaceURI(*args):\\n return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(*args)\",\n \"def test_get_namespaces_names(self):\\n pass\",\n \"def _index_and_mapping(self, namespace):\\n index, doc_type = namespace.split('.', 1)\\n return index.lower(), doc_type\",\n \"def address_space_prefixes(self) -> pulumi.Output[Sequence[str]]:\\n return pulumi.get(self, \\\"address_space_prefixes\\\")\",\n \"def getNamespaceURI(self, *args):\\n return _libsbml.XMLToken_getNamespaceURI(self, *args)\",\n \"def get_namespaces(self, label_selector=None):\\n return self.core_client.list_namespace(label_selector=label_selector)\",\n \"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\\\"})\",\n \"def get_namespace(self) -> str:\\n return self._namespace\",\n \"def getNamespaces(self):\\n return _libsbml.SBase_getNamespaces(self)\",\n \"def declareNamespace (self, namespace, prefix=None, add_to_map=False):\\n if not isinstance(namespace, pyxb.namespace.Namespace):\\n raise pyxb.UsageError('declareNamespace: must be given a namespace instance')\\n if namespace.isAbsentNamespace():\\n raise pyxb.UsageError('declareNamespace: namespace must not be an absent namespace')\\n if prefix is None:\\n prefix = namespace.prefix()\\n if prefix is None:\\n pfxs = self.__inScopePrefixes.get(namespace)\\n if pfxs:\\n prefix = next(iter(pfxs))\\n while prefix is None:\\n self.__namespacePrefixCounter += 1\\n candidate_prefix = 'ns%d' % (self.__namespacePrefixCounter,)\\n if not (candidate_prefix in self.__inScopeNamespaces):\\n prefix = candidate_prefix\\n ns = self.__inScopePrefixes.get(prefix)\\n if ns:\\n if ns != namespace:\\n raise pyxb.LogicError('Prefix %s is already in use for %s' % (prefix, ns))\\n return prefix\\n if not self.__mutableInScopeNamespaces:\\n self.__clonePrefixMap()\\n self.__mutableInScopeNamespaces = True\\n self.__addPrefixMap(prefix, namespace)\\n return prefix\",\n \"def get_namespace(key):\\n\\tif key not in REGISTRY:\\n\\t\\traise KeyError(\\\"key:{0} does not exist\\\".format(key))\\n\\n\\treturn REGISTRY[key]\",\n \"def _get_xpath_namespaces(self, namespaces: Optional[NamespacesType] = None) \\\\\\n -> Dict[str, str]:\\n if namespaces is None:\\n namespaces = {k: v for k, v in self.namespaces.items() if k}\\n namespaces[''] = self.xpath_default_namespace\\n elif '' not in namespaces:\\n namespaces[''] = self.xpath_default_namespace\\n\\n xpath_namespaces: Dict[str, str] = XPath2Parser.DEFAULT_NAMESPACES.copy()\\n xpath_namespaces.update(namespaces)\\n return xpath_namespaces\",\n \"def _getPrefixDict(self):\\r\\n if not hasattr(self, '_prefixDict'):\\r\\n self.__prefixDict = {}\\r\\n return self.__prefixDict\",\n \"def GetNamespaces(self):\\n return list(self.type_namespaces_map.values())\",\n \"def namespace(self) -> str:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def getIndex(self, *args):\\n return _libsbml.XMLNamespaces_getIndex(self, *args)\",\n \"def namespace(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def test_get_namespace(self):\\n pass\",\n \"def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"namespaces\\\")\",\n \"def namespace(self):\\n return self._namespace\",\n \"def namespace(self):\\n assert self._namespace\\n return self._namespace\",\n \"def namespace_to_dict(n):\\n assert isinstance(n, SimpleNamespace)\\n return _namespace_to_dict_util(n)\",\n \"def _DefaultNamespace():\\n return namespace_manager.get_namespace()\",\n \"def _get_xml_namespace(root_tag):\\n m = re.match(r\\\"\\\\{.*\\\\}\\\", root_tag)\\n return m.group(0) if m else \\\"\\\"\",\n \"def get_identifiers_org_namespace(prefix):\\n try:\\n return get_identifiers_org_namespaces()[prefix]\\n except KeyError:\\n raise InvalidIdentifiersOrgUri('`{}` is not a valid prefix of a Identifiers.org namespace.'.format(prefix))\",\n \"def prefixed_to_qname(name, namespaces):\\n if not name or name[0] == '{':\\n return name\\n\\n try:\\n prefix, name = name.split(':')\\n except ValueError:\\n if ':' in name:\\n raise XMLSchemaValueError(\\\"wrong format for reference name %r\\\" % name)\\n try:\\n uri = namespaces['']\\n except KeyError:\\n return name\\n else:\\n return '{%s}%s' % (uri, name) if uri else name\\n else:\\n if not prefix or not name:\\n raise XMLSchemaValueError(\\\"wrong format for reference name %r\\\" % name)\\n try:\\n uri = namespaces[prefix]\\n except KeyError:\\n raise XMLSchemaValueError(\\\"prefix %r not found in namespace map\\\" % prefix)\\n else:\\n return '{%s}%s' % (uri, name) if uri else name\",\n \"def _load_namespaces(self):\\n nsdocs = self._docset.get_namespaces()\\n for nsdoc in nsdocs:\\n nsobj = Namespace(nsdoc)\\n self._docmap[nsdoc] = nsobj\\n self._namespaces.add(nsobj)\",\n \"def get_uri_prefix() -> str:\\n Config.__get()\\n assert Config.__config is not None\\n return Config.__config.get(\\\"wsgi\\\", \\\"uri_prefix\\\").strip()\",\n \"def getURI(self, *args):\\n return _libsbml.XMLNamespaces_getURI(self, *args)\",\n \"def getNamespace(self):\\n pass;\",\n \"def get_constants(prefix):\\n return dict( (getattr(socket, n), n)\\n for n in dir(socket)\\n if n.startswith(prefix)\\n )\",\n \"def namespace(self) -> Optional[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> Optional[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> Optional[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def _load_namespaces(self, result):\\n self._namespaces = {}\\n\\n for namespace in result[\\\"query\\\"][\\\"namespaces\\\"].values():\\n ns_id = namespace[\\\"id\\\"]\\n name = namespace[\\\"*\\\"]\\n try:\\n canonical = namespace[\\\"canonical\\\"]\\n except KeyError:\\n self._namespaces[ns_id] = [name]\\n else:\\n if name != canonical:\\n self._namespaces[ns_id] = [name, canonical]\\n else:\\n self._namespaces[ns_id] = [name]\\n\\n for namespace in result[\\\"query\\\"][\\\"namespacealiases\\\"]:\\n ns_id = namespace[\\\"id\\\"]\\n alias = namespace[\\\"*\\\"]\\n self._namespaces[ns_id].append(alias)\",\n \"def namespaces(self):\\n if not self._namespaces:\\n self.update_namespaces_info()\\n\\n return self._namespaces\",\n \"def get(self, *args):\\n return _libsbml.ListWrapperSBMLNamespaces_get(self, *args)\",\n \"def namespace(self) -> str:\\n return self._namespace\",\n \"def get_namespaces():\\r\\n\\r\\n print 'Getting namespaces'\\r\\n tree = etree.parse('http://lesswrong.wikia.com/wiki/Special:AllPages', parser)\\r\\n options = tree.xpath('//select[@id=\\\"namespace\\\"]/option')\\r\\n namespaces = [option.get('value') for option in options]\\r\\n pprint(namespaces)\\r\\n return namespaces\",\n \"def getPrefix(self):\\n return _libsbml.XMLTriple_getPrefix(self)\",\n \"def get_prefixes(buildout):\\n\\n prefixes = parse_list(buildout.get('prefixes', ''))\\n return [os.path.abspath(k) for k in prefixes if os.path.exists(k)]\",\n \"def remap_prefixes(cmap):\\n cmap[\\\"MGI\\\"] = \\\"http://identifiers.org/mgi/MGI:\\\"\\n cmap[\\\"WB\\\"] = \\\"http://identifiers.org/wormbase/\\\"\\n return cmap\",\n \"def getNamespaces(self):\\n return _libsbml.SBMLDocument_getNamespaces(self)\",\n \"def namespaces(self) -> NamespacesType:\\n return self.schema.namespaces\",\n \"def getNamespaces(self):\\n return _libsbml.XMLToken_getNamespaces(self)\",\n \"def namespace (self) :\\n\\n return self.__namespace__\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def namespace(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"namespace\\\")\",\n \"def getURI(self):\\n return _libsbml.SBMLNamespaces_getURI(self)\",\n \"def prefix(self):\\n return self[\\\"prefix\\\"]\",\n \"def prefix(self):\\n return self[\\\"prefix\\\"]\",\n \"def xmlrpc_namespace():\",\n \"def _get_namespace(self, data):\\n ns_name = data['filename'].namespace\\n try:\\n return models.Namespace.objects.get(name=ns_name)\\n except models.Namespace.DoesNotExist:\\n raise exceptions.ValidationError(\\n f'Namespace \\\"{ns_name}\\\" does not exist.'\\n )\",\n \"def getPrefix(self):\\n return _libsbml.SBase_getPrefix(self)\",\n \"def getPrefix(self):\\n raise NotImplementedError\",\n \"def getNamespaceIndex(self, *args):\\n return _libsbml.XMLToken_getNamespaceIndex(self, *args)\",\n \"def namespace(self, namespace, lowercase=True, trim_namespace=True):\\n\\t\\treturn Config(\\n\\t\\t\\t\\tself.root_path,\\n\\t\\t\\t\\tself.get_namespace_view(namespace, lowercase, trim_namespace)\\n\\t\\t\\t)\",\n \"def get_constants(prefix):\\n return {\\n getattr(socket, n): n\\n for n in dir(socket)\\n if n.startswith(prefix)\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74894905","0.723001","0.7178781","0.7092518","0.7036941","0.6799343","0.67157125","0.67054284","0.66477394","0.6579663","0.64730036","0.646861","0.6420464","0.64164484","0.64045894","0.63432497","0.63370234","0.63120365","0.63070714","0.62537974","0.62380385","0.6221364","0.621491","0.6214344","0.62062514","0.6199084","0.61269677","0.6110802","0.60916305","0.60792","0.60053015","0.59371406","0.58909696","0.5887794","0.5874347","0.58507776","0.5849891","0.5849509","0.5849272","0.58485943","0.5837763","0.5827174","0.58189166","0.5805659","0.5804454","0.58023566","0.5791487","0.5791487","0.5791487","0.5791487","0.5791487","0.5771173","0.5769542","0.576573","0.5753271","0.5739721","0.573836","0.5736382","0.57145244","0.5693619","0.568704","0.5667896","0.5665741","0.5665281","0.5652284","0.564829","0.564829","0.564829","0.56460255","0.5613991","0.5591623","0.5590134","0.5584967","0.55844194","0.5581965","0.5579256","0.5569686","0.5567639","0.55638665","0.5553283","0.55432224","0.55432224","0.55432224","0.55432224","0.55432224","0.55432224","0.55432224","0.55432224","0.55432224","0.55432224","0.5527904","0.55248153","0.55248153","0.5518788","0.55155444","0.5504374","0.5495718","0.5474006","0.54726416","0.5470884"],"string":"[\n \"0.74894905\",\n \"0.723001\",\n \"0.7178781\",\n \"0.7092518\",\n \"0.7036941\",\n \"0.6799343\",\n \"0.67157125\",\n \"0.67054284\",\n \"0.66477394\",\n \"0.6579663\",\n \"0.64730036\",\n \"0.646861\",\n \"0.6420464\",\n \"0.64164484\",\n \"0.64045894\",\n \"0.63432497\",\n \"0.63370234\",\n \"0.63120365\",\n \"0.63070714\",\n \"0.62537974\",\n \"0.62380385\",\n \"0.6221364\",\n \"0.621491\",\n \"0.6214344\",\n \"0.62062514\",\n \"0.6199084\",\n \"0.61269677\",\n \"0.6110802\",\n \"0.60916305\",\n \"0.60792\",\n \"0.60053015\",\n \"0.59371406\",\n \"0.58909696\",\n \"0.5887794\",\n \"0.5874347\",\n \"0.58507776\",\n \"0.5849891\",\n \"0.5849509\",\n \"0.5849272\",\n \"0.58485943\",\n \"0.5837763\",\n \"0.5827174\",\n \"0.58189166\",\n \"0.5805659\",\n \"0.5804454\",\n \"0.58023566\",\n \"0.5791487\",\n \"0.5791487\",\n \"0.5791487\",\n \"0.5791487\",\n \"0.5791487\",\n \"0.5771173\",\n \"0.5769542\",\n \"0.576573\",\n \"0.5753271\",\n \"0.5739721\",\n \"0.573836\",\n \"0.5736382\",\n \"0.57145244\",\n \"0.5693619\",\n \"0.568704\",\n \"0.5667896\",\n \"0.5665741\",\n \"0.5665281\",\n \"0.5652284\",\n \"0.564829\",\n \"0.564829\",\n \"0.564829\",\n \"0.56460255\",\n \"0.5613991\",\n \"0.5591623\",\n \"0.5590134\",\n \"0.5584967\",\n \"0.55844194\",\n \"0.5581965\",\n \"0.5579256\",\n \"0.5569686\",\n \"0.5567639\",\n \"0.55638665\",\n \"0.5553283\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.55432224\",\n \"0.5527904\",\n \"0.55248153\",\n \"0.55248153\",\n \"0.5518788\",\n \"0.55155444\",\n \"0.5504374\",\n \"0.5495718\",\n \"0.5474006\",\n \"0.54726416\",\n \"0.5470884\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78372264"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":16,"numItemsPerPage":100,"numTotalItems":95772,"offset":1600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzYxMjY3NSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM2MTYyNzUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Rgvwj98c5w4brBqVkFskda8VD2WjY4o9x5X5cp7geDgZwNknnCeTCbftPVPTUVXD7l4mEn-s4AAuQ1vm_2IaCA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102 values |
|---|---|---|---|---|---|---|
Report usage metrics for all active Crypto Express adapters of CPCs. In addition to the commandspecific options shown in this help text, the general options (see 'zhmc help') can also be specified right after the 'zhmc' command name. | def metrics_crypto(cmd_ctx, cpc, **options):
cmd_ctx.execute_cmd(lambda: cmd_metrics_crypto(cmd_ctx, cpc, options)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metrics_channel(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_channel(cmd_ctx, cpc, options))",
"def metrics_adapter(cmd_ctx, cpc, adapter, **options):\n cmd_ctx.execute_cmd(\n lambda: cmd_metrics_adapter(cmd_ctx, cpc, adapter, options))",
"def do_hostinfo(self, args):\n ... | [
"0.61710244",
"0.5943986",
"0.5742064",
"0.5595102",
"0.55200773",
"0.54445076",
"0.5411969",
"0.53798133",
"0.5354008",
"0.535235",
"0.5349474",
"0.5332392",
"0.53124905",
"0.5226011",
"0.51669437",
"0.51390135",
"0.5104674",
"0.5103828",
"0.50836706",
"0.5078611",
"0.507831... | 0.6303562 | 0 |
Report usage metrics for all active Flash Express adapters of CPCs. In addition to the commandspecific options shown in this help text, the general options (see 'zhmc help') can also be specified right after the 'zhmc' command name. | def metrics_flash(cmd_ctx, cpc, **options):
cmd_ctx.execute_cmd(lambda: cmd_metrics_flash(cmd_ctx, cpc, options)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metrics_channel(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_channel(cmd_ctx, cpc, options))",
"def metrics_adapter(cmd_ctx, cpc, adapter, **options):\n cmd_ctx.execute_cmd(\n lambda: cmd_metrics_adapter(cmd_ctx, cpc, adapter, options))",
"def do_hostinfo(self, args):\n ... | [
"0.617125",
"0.58856094",
"0.5707514",
"0.5675522",
"0.5634532",
"0.54365146",
"0.53614813",
"0.53592706",
"0.53404266",
"0.53303754",
"0.5302817",
"0.5274004",
"0.5224067",
"0.52236396",
"0.52125716",
"0.51809424",
"0.51480365",
"0.5107816",
"0.5101575",
"0.50771254",
"0.506... | 0.5578356 | 5 |
Report usage metrics for all active RoCE adapters of CPCs. In addition to the commandspecific options shown in this help text, the general options (see 'zhmc help') can also be specified right after the 'zhmc' command name. | def metrics_roce(cmd_ctx, cpc, **options):
cmd_ctx.execute_cmd(lambda: cmd_metrics_roce(cmd_ctx, cpc, options)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metrics_channel(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_channel(cmd_ctx, cpc, options))",
"def metrics_crypto(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_crypto(cmd_ctx, cpc, options))",
"def metrics_adapter(cmd_ctx, cpc, adapter, **options):\n c... | [
"0.6161586",
"0.5805755",
"0.5797474",
"0.5729157",
"0.563271",
"0.55953175",
"0.5529902",
"0.55097723",
"0.54637194",
"0.54599464",
"0.54326856",
"0.5381607",
"0.5343133",
"0.5302566",
"0.52546537",
"0.52469516",
"0.52173275",
"0.5206837",
"0.5200306",
"0.51897854",
"0.51727... | 0.54437673 | 10 |
Report usage metrics for the ports of network adapters of CPCs in DPM mode. In addition to the commandspecific options shown in this help text, the general options (see 'zhmc help') can also be specified right after the 'zhmc' command name. | def metrics_networkport(cmd_ctx, cpc, adapter, **options):
cmd_ctx.execute_cmd(
lambda: cmd_metrics_networkport(cmd_ctx, cpc, adapter, options)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metrics_channel(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_channel(cmd_ctx, cpc, options))",
"def metrics_adapter(cmd_ctx, cpc, adapter, **options):\n cmd_ctx.execute_cmd(\n lambda: cmd_metrics_adapter(cmd_ctx, cpc, adapter, options))",
"def do_hostinfo(self, args):\n ... | [
"0.6124976",
"0.59950477",
"0.5756093",
"0.5687688",
"0.55233353",
"0.5309227",
"0.52750784",
"0.5252932",
"0.5208929",
"0.5170246",
"0.5106128",
"0.50764817",
"0.50519806",
"0.50233275",
"0.5003854",
"0.4984393",
"0.4930946",
"0.49051604",
"0.49042228",
"0.49029616",
"0.4877... | 0.70290184 | 0 |
Report usage metrics for the NICs of partitions of CPCs in DPM mode. In addition to the commandspecific options shown in this help text, the general options (see 'zhmc help') can also be specified right after the 'zhmc' command name. | def metrics_nic(cmd_ctx, cpc, partition, nic, **options):
cmd_ctx.execute_cmd(
lambda: cmd_metrics_nic(cmd_ctx, cpc, partition, nic, options)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metrics_cpc(cmd_ctx, cpc, **options):\n cmd_ctx.execute_cmd(lambda: cmd_metrics_cpc(cmd_ctx, cpc, options))",
"def metrics_networkport(cmd_ctx, cpc, adapter, **options):\n cmd_ctx.execute_cmd(\n lambda: cmd_metrics_networkport(cmd_ctx, cpc, adapter, options))",
"def metrics_channel(cmd_ctx, cp... | [
"0.6029862",
"0.59694433",
"0.593867",
"0.5872437",
"0.57943094",
"0.56738853",
"0.5640134",
"0.5486397",
"0.5422634",
"0.53095937",
"0.5250618",
"0.5230403",
"0.510633",
"0.5087089",
"0.50808835",
"0.5045866",
"0.49836123",
"0.4982057",
"0.49766484",
"0.4954867",
"0.49396986... | 0.6058172 | 0 |
A decorator that uses cProfile to profile a function | def profile(fnc):
def inner(*args, **kwargs):
pr = cProfile.Profile()
pr.enable()
retval = fnc(*args, **kwargs)
pr.disable()
s = io.StringIO()
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats()
logging.info(s.getvalue())
return retval
return inner | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def profile(func):\n def wrapper(*args, **kwargs):\n profile_filename = func.__name__ + '.prof'\n profiler = cProfile.Profile()\n result = profiler.runcall(func, *args, **kwargs)\n profiler.dump_stats(profile_filename)\n return result\n return wrapper",
"def profile(func)... | [
"0.84530425",
"0.8446885",
"0.82060313",
"0.81897914",
"0.81137836",
"0.805328",
"0.7986637",
"0.7973362",
"0.77897024",
"0.77074057",
"0.77040017",
"0.7657467",
"0.7563646",
"0.7490806",
"0.74640775",
"0.7423344",
"0.7059046",
"0.7050842",
"0.6984666",
"0.6982411",
"0.693029... | 0.783562 | 8 |
Number of days left. | def ssl_valid_time_remaining(domainname):
expires = ssl_expiry_date(domainname)
return expires - datetime.datetime.utcnow().date() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_number_days(self):\r\n return 1",
"def elapsed_days(self) -> int:\n return (datetime.today() - self.release_datetime).days",
"def remaining_days_in_current_period(self):\n try:\n return self.count_days_from_now(self.current_period_ends_at)\n except AttributeError:... | [
"0.7505091",
"0.7279096",
"0.7158447",
"0.71100044",
"0.7087657",
"0.70665115",
"0.7026382",
"0.7017739",
"0.6946899",
"0.69389665",
"0.6917387",
"0.6910316",
"0.6885656",
"0.68470883",
"0.6816302",
"0.6804258",
"0.6734145",
"0.670508",
"0.6679895",
"0.6673183",
"0.66385496",... | 0.0 | -1 |
Returns the truncated SHA521 hash of the message. | def get_hash(data, n):
import hashlib
message_hash = hashlib.sha512(data).digest()
e = int.from_bytes(message_hash, 'big')
# FIPS 180 says that when a hash needs to be truncated, the rightmost bits
# should be discarded.
z = e >> (e.bit_length() - n.bit_length())
assert z.bit_length() <= n.bit_length()
return z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sha512(message):\n return hashlib.sha512(message).hexdigest()",
"def _sha512(data):\r\n return hashlib.sha512(data).hexdigest()",
"def sha512(s: str) -> str:\n return hashlib.sha512(s.encode()).hexdigest()",
"def _hash(data):\n return hashlib.sha512(data).hexdigest()",
"def get_sha512_... | [
"0.7193293",
"0.6325299",
"0.61913234",
"0.5894766",
"0.58219564",
"0.57631546",
"0.5762267",
"0.5743988",
"0.5704884",
"0.56312925",
"0.56283605",
"0.56206113",
"0.54951626",
"0.54939073",
"0.54397",
"0.5402861",
"0.539359",
"0.5392251",
"0.535287",
"0.534708",
"0.5297465",
... | 0.5229747 | 24 |
Computes the Modulation SpectrumBased ECG Quality Index (MSQI) for one or many ECG signals defined in x, sampled with a sampling frequency fs | def msqi_ama(x, fs):
# test ecg shape
try:
x.shape[1]
except IndexError:
x = x[:, np.newaxis]
# Empirical values for the STFFT transformation
win_size_sec = 0.125 #seconds
win_over_sec = 0.09375 #seconds
nfft_factor_1 = 16
nfft_factor_2 = 4
win_size_smp = int(win_size_sec * fs) #samples
win_over_smp = int(win_over_sec * fs) #samples
win_shft_smp = win_size_smp - win_over_smp
# Computes Modulation Spectrogram
modulation_spectrogram = ama.strfft_modulation_spectrogram(x, fs, win_size_smp,
win_shft_smp, nfft_factor_1, 'cosine', nfft_factor_2, 'cosine' )
# Find fundamental frequency (HR)
# f = (0, 40)Hz
ix_f_00 = (np.abs(modulation_spectrogram['freq_axis'] - 0)).argmin(0)
ix_f_40 = (np.abs(modulation_spectrogram['freq_axis'] - 40)).argmin(0) + 1
# Look for the maximum only from 0.6 to 3 Hz (36 to 180 bpm)
valid_f_ix = np.logical_or(modulation_spectrogram['freq_mod_axis'] < 0.66 , modulation_spectrogram['freq_mod_axis'] > 3)
# number of epochs
n_epochs = modulation_spectrogram['power_modulation_spectrogram'].shape[2]
msqi_vals = np.zeros(n_epochs)
hr_vals = np.zeros(n_epochs)
for ix_epoch in range(n_epochs):
B = np.sqrt(modulation_spectrogram['power_modulation_spectrogram'][:, :, ix_epoch])
# Scale to maximun of B
B = B / np.max(B)
# Add B in the conventional frequency axis from 0 to 40 Hz
tmp = np.sum(B[ix_f_00:ix_f_40, :], axis=0)
# Look for the maximum only from 0.6 to 3 Hz (36 to 180 bpm)
tmp[valid_f_ix] = 0
ix_max = np.argmax(tmp)
freq_funda = modulation_spectrogram['freq_mod_axis'][ix_max]
# TME
tme = np.sum(B)
eme = 0
for ix_harm in range(1, 5):
ix_fm = (np.abs(modulation_spectrogram['freq_mod_axis'] - (ix_harm * freq_funda) )).argmin(0)
ix_b = int(round(.3125 / modulation_spectrogram['freq_mod_delta'] )) # 0.3125Hz, half lobe
# EME
eme = eme + np.sum(B[ 0 : ix_f_40, ix_fm - ix_b : ix_fm + ix_b + 1 ])
# RME
rme = tme - eme
# MS-QI
msqi_vals[ix_epoch] = eme / rme
# HR
hr_vals[ix_epoch] = freq_funda * 60
return (msqi_vals, hr_vals, modulation_spectrogram) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_optimal_Q(x, y, data, min_Q, max_Q, fs=1., added_kernel = None, plot_BIC=True):\n Qs= np.arange(min_Q, max_Q)\n BIC = np.zeros((Qs.shape[0]))\n \n for i, q in enumerate(Qs):\n sm = SpectralMixture(q, x=x.flatten(),y=y.flatten(),fs=fs)\n for k in sm.kernels:\n ... | [
"0.5476735",
"0.5465266",
"0.5431895",
"0.5348803",
"0.5319814",
"0.5249597",
"0.5233212",
"0.52282983",
"0.51446587",
"0.51347893",
"0.51147515",
"0.5109146",
"0.50809836",
"0.50781864",
"0.5074541",
"0.50507593",
"0.5049618",
"0.5042971",
"0.50428605",
"0.5027192",
"0.50248... | 0.64019674 | 0 |
Helper function to convert raw lines into a minibatch as a DotDict. | def process_batch(self, lines):
batch_edges = []
batch_edges_values = []
batch_edges_target = [] # Binary classification targets (0/1)
batch_nodes = []
batch_nodes_target = [] # Multi-class classification targets (`num_nodes` classes)
batch_nodes_coord = []
batch_mst_edges = []
batch_mst_len = []
for line_num, line in enumerate(lines):
line = line.split(" ") # Split into list
# Compute signal on nodes
nodes = np.ones(self.num_nodes) # All 1s for TSP...
# Convert node coordinates to required format
nodes_coord = []
for idx in range(0, 2 * self.num_nodes, 2):
nodes_coord.append([float(line[idx]), float(line[idx + 1])])
# Compute distance matrix
W_val = squareform(pdist(nodes_coord, metric='euclidean'))
# Compute adjacency matrix
if self.num_neighbors == -1:
W = np.ones((self.num_nodes, self.num_nodes)) # Graph is fully connected
else:
W = np.zeros((self.num_nodes, self.num_nodes))
# Determine k-nearest neighbors for each node
knns = np.argpartition(W_val, kth=self.num_neighbors, axis=-1)[:, self.num_neighbors::-1]
# Make connections
for idx in range(self.num_nodes):
W[idx][knns[idx]] = 1
np.fill_diagonal(W, 2) # Special token for self-connections
# Convert tour nodes to required format
# Don't add final connection for tour/cycle
_edges = [edge for edge in line[line.index('output') + 1:]]
mst_edges = [literal_eval(' '.join(_edges[i:i+2])) for i in range(0, len(_edges),2)] # gets the edges from line --> equivalent to tour_nodes for TSP
# Compute node and edge representation of mst + mst_len
mst_len = 0 # length of mst
nodes_target = np.zeros(self.num_nodes)
edges_target = np.zeros((self.num_nodes, self.num_nodes))
for idx in range(len(mst_edges)):
i = mst_edges[idx][0]
j = mst_edges[idx][1]
nodes_target[i] = idx # node targets: ordering of nodes in tour
edges_target[i][j] = 1
edges_target[j][i] = 1
mst_len += W_val[i][j]
# Concatenate the data
batch_edges.append(W)
batch_edges_values.append(W_val)
batch_edges_target.append(edges_target)
batch_nodes.append(nodes)
batch_nodes_target.append(nodes_target)
batch_nodes_coord.append(nodes_coord)
batch_mst_edges.append(mst_edges)
batch_mst_len.append(mst_len)
# From list to tensors as a DotDict
batch = DotDict()
batch.edges = np.stack(batch_edges, axis=0)
batch.edges_values = np.stack(batch_edges_values, axis=0)
batch.edges_target = np.stack(batch_edges_target, axis=0)
batch.nodes = np.stack(batch_nodes, axis=0)
batch.nodes_target = np.stack(batch_nodes_target, axis=0)
batch.nodes_coord = np.stack(batch_nodes_coord, axis=0)
batch.mst_edges = np.stack(batch_mst_edges, axis=0)
batch.mst_len = np.stack(batch_mst_len, axis=0)
return batch | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_lines_to_dict(lines):\n res = {k: v.strip() for k, v in (m.split(':', 1) for m in lines)}\n return res",
"def dictFromLines(lines,sep=None):\n reComment = re.compile('#.*')\n temp = [reComment.sub('',x).strip() for x in lines.split('\\n')]\n if sep == None or type(sep) == type(''):\n ... | [
"0.5950162",
"0.57444644",
"0.5603637",
"0.54143274",
"0.5345499",
"0.53329337",
"0.5319959",
"0.53030837",
"0.52169234",
"0.5213757",
"0.5200185",
"0.51813257",
"0.5157761",
"0.5150942",
"0.5118812",
"0.5090973",
"0.50735104",
"0.5071656",
"0.5063901",
"0.50526667",
"0.50393... | 0.0 | -1 |
Load the image on initial load of the application | def OnInit(self):
self.imageID = self.loadImage() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OnInit( self ):\n self.imageID = self.loadImage ()",
"def load_image(self, **kwargs):\n ...",
"def load_image(self):\n # Minimal progress display while image is loaded.\n group = displayio.Group()\n group.append(centered_label('LOADING...', 40, 3))\n #self.rect = R... | [
"0.7676823",
"0.72862685",
"0.6990877",
"0.69560045",
"0.69560045",
"0.69560045",
"0.6736933",
"0.66402304",
"0.6628148",
"0.65887284",
"0.65709776",
"0.6562708",
"0.6558569",
"0.6513278",
"0.64529467",
"0.6451759",
"0.6443347",
"0.64257944",
"0.64138216",
"0.6399771",
"0.637... | 0.77568126 | 0 |
Load an image file as a 2D texture using PIL | def loadImage(self, imageName="nehe_wall.bmp"):
# PIL defines an "open" method which is Image specific!
im = open(imageName)
try:
ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBA", 0, -1)
except SystemError:
ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBX", 0, -1)
# Generate a texture ID
ID = glGenTextures(1)
# Make our new texture ID the current 2D texture
glBindTexture(GL_TEXTURE_2D, ID)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
# Copy the texture data into the current texture ID
glTexImage2D(
GL_TEXTURE_2D, 0, 3, ix, iy, 0,
GL_RGBA, GL_UNSIGNED_BYTE, image
)
"""
Note that only the ID is returned, no reference to the image object
or the string data is stored in user space, the data is only present
within the GL after this call exits.
"""
return ID | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_texture(file_name, x=0, y=0, width=0, height=0, scale=1):\n\n # See if we already loaded this file, and we can just use a cached version.\n if file_name in load_texture.texture_cache:\n return load_texture.texture_cache[file_name]\n\n source_image = PIL.Image.open(file_name)\n\n source_... | [
"0.7242643",
"0.71882534",
"0.7155117",
"0.7069824",
"0.70061564",
"0.70061564",
"0.69536114",
"0.68268985",
"0.68221575",
"0.6817364",
"0.6731701",
"0.6718896",
"0.6691872",
"0.6541551",
"0.65246266",
"0.6514948",
"0.6454194",
"0.6423829",
"0.6403943",
"0.63669056",
"0.63510... | 0.6440027 | 17 |
Rendertime texture environment setup | def setupTexture(self):
# Configure the texture rendering parameters
glEnable(GL_TEXTURE_2D)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
# Re-select our texture, could use other generated textures
# if we had generated them earlier.
glBindTexture(GL_TEXTURE_2D, self.imageID) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_environment_texture(self, texture, is_srgb=False):\n # cube_map textures cannot use spherical harmonics\n if texture.cube_map:\n self.AutomaticLightCreationOff()\n # disable spherical harmonics was added in 9.1.0\n if hasattr(self, 'UseSphericalHarmonicsOff'):... | [
"0.61697626",
"0.6057704",
"0.57795113",
"0.5687284",
"0.56449056",
"0.55825335",
"0.5524036",
"0.5497377",
"0.5459231",
"0.5422027",
"0.5419896",
"0.5402457",
"0.5394463",
"0.5369188",
"0.53376245",
"0.5336224",
"0.5335161",
"0.5335161",
"0.5328675",
"0.5311985",
"0.5309703"... | 0.5953139 | 2 |
Draw a cube with texture coordinates | def drawCube(self):
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0);
glVertex3f(-1.0, -1.0, 1.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, -1.0, 1.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, 1.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, 1.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(-1.0, -1.0, -1.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(-1.0, 1.0, -1.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(1.0, 1.0, -1.0);
glTexCoord2f(0.0, 0.0);
glVertex3f(1.0, -1.0, -1.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, -1.0);
glTexCoord2f(0.0, 0.0);
glVertex3f(-1.0, 1.0, 1.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, 1.0, 1.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, -1.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(-1.0, -1.0, -1.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(1.0, -1.0, -1.0);
glTexCoord2f(0.0, 0.0);
glVertex3f(1.0, -1.0, 1.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(-1.0, -1.0, 1.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, -1.0, -1.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, -1.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(1.0, 1.0, 1.0);
glTexCoord2f(0.0, 0.0);
glVertex3f(1.0, -1.0, 1.0);
glTexCoord2f(0.0, 0.0);
glVertex3f(-1.0, -1.0, -1.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(-1.0, -1.0, 1.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(-1.0, 1.0, 1.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, -1.0);
glEnd() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drawCube( self ):\n glBegin(GL_QUADS);\n glTexCoord2f(0.0, 0.0); glVertex3f(-1.0, -1.0, 1.0);\n glTexCoord2f(1.0, 0.0); glVertex3f( 1.0, -1.0, 1.0);\n glTexCoord2f(1.0, 1.0); glVertex3f( 1.0, 1.0, 1.0);\n glTexCoord2f(0.0, 1.0); glVertex3f(-1.0, 1.0, 1.0);\n glTe... | [
"0.8082414",
"0.790963",
"0.73804325",
"0.7115595",
"0.7054056",
"0.70481575",
"0.6607423",
"0.6532412",
"0.64749116",
"0.6449474",
"0.6229988",
"0.6222093",
"0.6187685",
"0.61688286",
"0.6162942",
"0.6152132",
"0.6028768",
"0.59879607",
"0.5984257",
"0.59456533",
"0.5933637"... | 0.80746436 | 1 |
Request refresh of the context whenever idle | def OnIdle(self, ):
self.triggerRedraw(1)
return 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def idle(self):\n return",
"def on_refresh(self):\n pass",
"def idle():",
"def _idle(self):\n # self._purge_timedout()\n # ...",
"def refresh(self):\n pass",
"def refresh(self):\n pass",
"def refresh(self):\n\n self._refreshed_on = time.time() * 1000",
... | [
"0.6957455",
"0.6568586",
"0.65202016",
"0.64047533",
"0.6379513",
"0.6379513",
"0.63642436",
"0.6357043",
"0.6318813",
"0.6293459",
"0.6293459",
"0.6293459",
"0.6279487",
"0.6272733",
"0.6181421",
"0.6174326",
"0.61006075",
"0.60482174",
"0.60439646",
"0.60439646",
"0.604372... | 0.5446337 | 81 |
Continually read and add messages to the chat. | def _receive_message_loop(self):
while True:
try:
message = self.connection_socket.recv(4096)
if len(message) > 0:
self.add_message_to_chat(message.decode('utf-8'))
sleep(0.2)
except ConnectionResetError:
# messagebox.showerror("Client dropped", "The other person has dropped from the connection.")
self.root.destroy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_chat(self):\n while True:\n if self.chat_breakout:\n return\n\n time.sleep(1)\n messages = \"\"\n for i in range(5):\n try:\n messages += f\"{self.queue.popleft()}\\n\"\n except IndexError:... | [
"0.69138986",
"0.6706282",
"0.6597729",
"0.65439147",
"0.64965916",
"0.64251614",
"0.6425156",
"0.64248693",
"0.64159244",
"0.6353749",
"0.63389343",
"0.63240904",
"0.6288118",
"0.6244579",
"0.6240275",
"0.621565",
"0.61916894",
"0.61845356",
"0.6172189",
"0.610745",
"0.61024... | 0.5676125 | 72 |
Sends the message over the socket and also adds it to the chat. | def _send_message(self, e: Event):
message = self.message_text.get("1.0", 'end-1c').replace('\n', "")
if len(message) > 0:
self.add_message_to_chat('you: ' + message)
self._clear_message_text()
self.connection_socket.send(bytes('them: ' + message, 'utf-8')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sendChatMessage(self, msg):\n self.transport.write(msg)",
"def send_message(self, message):\n \n msgPacket = serverbound.play.ChatPacket()\n msgPacket.message = message\n self.connection.write_packet(msgPacket)",
"def send_message(self, message):\r\n\t\tself.__tcpSocket.w... | [
"0.8096262",
"0.7986446",
"0.781855",
"0.77682155",
"0.7713088",
"0.7641384",
"0.7619159",
"0.75668764",
"0.75613767",
"0.75334066",
"0.7495466",
"0.74901545",
"0.74558794",
"0.74528867",
"0.73387706",
"0.7315095",
"0.72622466",
"0.7216694",
"0.7187263",
"0.7170448",
"0.71642... | 0.70444596 | 34 |
Adds a message to the chat and scrolls down. | def add_message_to_chat(self, message: str):
scroll_length = (len(message) // Client.TEXTBOX_CHARACTER_LENGTH) + 1
self.chat_text.config(state=NORMAL)
self.chat_text.insert(END, message + '\n')
self.chat_text.yview_scroll(scroll_length, "units")
self.chat_text.config(state=DISABLED) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_add_chat_message(self, chat_message):\n self.chat_messages.append(chat_message)\n\n #logging.info(\"adding message: %s\" % chat_message.message)\n\n if len(self.chat_messages) > ENVIRONMENT['BUFFER_SIZE']:\n self.chat_messages.pop(0)\n\n # alert our polling clients\n... | [
"0.6858262",
"0.68089944",
"0.6778456",
"0.67170316",
"0.66270477",
"0.65076065",
"0.6480786",
"0.6332747",
"0.6320004",
"0.6282979",
"0.6253987",
"0.6231954",
"0.6195",
"0.6192585",
"0.61682373",
"0.61682373",
"0.6153406",
"0.61134017",
"0.6108938",
"0.60916406",
"0.60653615... | 0.799143 | 0 |
Creates a data folder containing a 100class subset of ImageNet, then creates a zipped copy of it | def zip_imagenet100c():
#First make sure the directory we are given is correct!
if not os.path.isdir(DATA_SRC_ROOT):
raise Exception("Bad filepath given")
#create the destiantion directories if they don't exist
if not os.path.isdir(IMAGENET100_DIR):
os.mkdir(IMAGENET100_DIR)
#grab the subset wnids for the 100 class-subset
with open(IMAGENET100_CLASSES) as f:
subset_wnids = f.readlines()
subset_wnids = [x.strip() for x in subset_wnids] #list of the 100 WNIDs we grab
#Grab the names of all of the folders inside the root data source
#Structure is distortion/sub_distortion/level/wnids
for distortion in os.listdir(DATA_SRC_ROOT):
if distortion != "meta.bin":
print(distortion)
folder_path = os.path.join(DATA_SRC_ROOT, distortion)
if not os.path.isdir(folder_path):
continue
for sub_distortion in os.listdir(folder_path):
print(sub_distortion)
subfolder_path = os.path.join(folder_path, sub_distortion)
if not os.path.isdir(subfolder_path):
continue
for level in os.listdir(subfolder_path):
print(level)
level_path = os.path.join(subfolder_path, level)
#grab the correcrt validation d9recotires
for wnid in os.listdir(level_path):
wnid_path = os.path.join(level_path, wnid)
if not os.path.isdir(wnid_path):
continue
if wnid in subset_wnids:
dest_path = os.path.join(IMAGENET100_DIR, distortion, sub_distortion, level, wnid)
shutil.copytree(wnid_path, dest_path)
#copy the metadata bin file
meta_file = os.path.join(DATA_SRC_ROOT, 'meta.bin')
meta_dest = os.path.join(IMAGENET100_DIR, 'meta.bin')
shutil.copy(meta_file, meta_dest)
#Zip the destinatio file
shutil.make_archive(ZIP_PATH + '/ImageNet100C', 'tar', IMAGENET100_DIR) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dataset(data_folder: str, dataset_file: str, targets_file: str = os.path.join('data', 'targets.pkl')):\n files = sorted(glob.glob(os.path.join(data_folder, '**/*.jpg'), recursive=True))\n images = []\n crop_sizes = []\n crop_centers = []\n targets = []\n for image in tqdm(files, desc='... | [
"0.6529704",
"0.6481513",
"0.6435279",
"0.6418067",
"0.63397163",
"0.6227401",
"0.62035155",
"0.61983734",
"0.6165103",
"0.61225355",
"0.612228",
"0.60964",
"0.60848254",
"0.6073827",
"0.60563177",
"0.6047265",
"0.60234",
"0.6019958",
"0.60174394",
"0.6004536",
"0.5983722",
... | 0.7347322 | 0 |
Given a wav file, use Praat to return a dictionary containing pitch (in Hz) at each millisecond. | def praat_analyze_pitch(audio_file):
praatpath = path.abspath('Praat.app/Contents/MacOS/Praat') # locate Praat executable
pl = PraatLoader(praatpath=praatpath) # create instance of PraatLoader object
praat_output = pl.run_script('pitch.praat', audio_file) # run pitch script in Praat
pitch_data = pl.read_praat_out(praat_output) # turn Praat's output into Python dict
return pitch_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_pitch_from_sound_file(filename: str, samplerate: int = DEFAULT_SAMPLE_RATE):\n if os.path.isfile(filename) is False:\n raise Exception('File not found with filename = %s' % filename)\n\n print(\"====> reading pitch from sound file\")\n win_s = 4096 // DOWN_SAMPLE # fft size\n hop_s = 5... | [
"0.70273054",
"0.70135546",
"0.68500084",
"0.6821027",
"0.6812894",
"0.6796246",
"0.65991676",
"0.6327907",
"0.6325302",
"0.62763965",
"0.62052196",
"0.61778903",
"0.60919714",
"0.60821027",
"0.60718834",
"0.60426664",
"0.59239006",
"0.59204537",
"0.5904547",
"0.58931905",
"0... | 0.6584172 | 7 |
Clean up the dictionary returned by praatinterface, put it in the format needed for graphing, smooth data by reducing number of datapoints, and return it as JSON. | def format_pitch_data(pd):
for t in pd.keys():
pd[t] = pd[t]['Pitch'] # make each value just the pitch, instead of a sub-dict
if pd[t] == 0:
del pd[t] # if pitch is 0, remove from dictionary
# now, pd is dict where each key is time (x value) and each value is pitch (y value)
# to format for graph input, make list of dicts containing x-y pairs
datapoints_list = []
for t in pd.keys():
datapoint = {}
datapoint["x"] = t
datapoint["y"] = pd[t]
datapoints_list.append(datapoint)
# sort the list by the value of "x"
datapoints_sorted = sorted(datapoints_list, key=itemgetter("x"))
# with this sorted list, do some data smoothing
# pull out every nth item
i = 0
datapoints_keep = []
while i < len(datapoints_sorted):
datapoints_keep.append(datapoints_sorted[i])
i += 50
# make sure last item is included so length of curve isn't lost
datapoints_keep.append(datapoints_sorted[-1])
# print "num of datapoints:", len(datapoints_keep)
# print datapoints_keep[:100]
return json.dumps(datapoints_keep, sort_keys=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_json(self):\n data = {}\n data['ip'] = self.ip\n\n try:\n data['country'] = self.processedvtdata[\"country\"]\n except KeyError:\n data['country'] = 'None'\n try:\n data['as'] = self.processedvtdata[\"as_owner\"]\n except KeyError:\... | [
"0.65398073",
"0.63518214",
"0.6286521",
"0.61414844",
"0.6091616",
"0.6031922",
"0.6015514",
"0.6000563",
"0.59230435",
"0.59183973",
"0.590805",
"0.5886959",
"0.5885497",
"0.5877358",
"0.5861081",
"0.58608174",
"0.58516765",
"0.58342355",
"0.57904774",
"0.5777289",
"0.57518... | 0.5780186 | 19 |
Show the popup and return True if accepted, False if canceled. | def popup(self):
return self.exec_() == QDialog.Accepted | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_popup(self, type):",
"def _show_popup(self) -> None:\n\n top = tk.Toplevel()\n email_list_len = len(self.get_recipients())\n msg = tk.messagebox.askquestion('Confirm send emails', 'Are you sure you want to email {} client{}?'\n .format(email_... | [
"0.6642623",
"0.6464855",
"0.63802284",
"0.62683916",
"0.6240332",
"0.6218975",
"0.6172441",
"0.61592615",
"0.6059267",
"0.5996099",
"0.5937343",
"0.5933337",
"0.5915153",
"0.5883959",
"0.5883959",
"0.5883959",
"0.58716357",
"0.58673215",
"0.5851311",
"0.5851311",
"0.5847941"... | 0.79470927 | 0 |
Fill the heavy metal unit labels with the selected unit. | def set_hm_unit_display(self):
units = str(self.entries['units'].combobox.currentText())
self.ui.is_unitL1.setText(units)
self.ui.is_unitL2.setText(units)
self.ui.is_unitL3.setText(units)
self.ui.is_unitL4.setText(units) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unit_label(self, unit_label):\n\n self._unit_label = unit_label",
"def unit_label(self, unit_label):\n\n self._unit_label = unit_label",
"def unit_label(self, unit_label):\n\n self._unit_label = unit_label",
"def update_units(self):\n unit_var_value = self.view.vars['unit'].ge... | [
"0.65493584",
"0.65493584",
"0.65493584",
"0.61209",
"0.5876205",
"0.5848301",
"0.5719211",
"0.56192005",
"0.56159955",
"0.5609573",
"0.55953413",
"0.55090725",
"0.5500092",
"0.54777503",
"0.54361576",
"0.5392763",
"0.5386514",
"0.53529835",
"0.5319486",
"0.53029513",
"0.5297... | 0.6863121 | 0 |
Seek to the given time. | def seek_to(self, ms):
self.proxy.seek_to(ms) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def seek(self, time):\n command = 'seek ' + str(time)\n self.run_command(command)",
"def seek(self, time: int):\n self._select_interface(self._rc_seek, self._http_seek, time)",
"def _seek(self, time_offset):\n if (time.time() - (self.time_start + self.time_offset)) < 0.1:\n log.i... | [
"0.7862459",
"0.73034114",
"0.69887996",
"0.6565575",
"0.64587533",
"0.6248209",
"0.5942373",
"0.58812505",
"0.5810669",
"0.5806339",
"0.5791968",
"0.577806",
"0.577806",
"0.57382905",
"0.5731552",
"0.57055503",
"0.56437117",
"0.5611064",
"0.55878776",
"0.5579256",
"0.5579256... | 0.65188617 | 4 |
Create the task on the server | def create(self, server):
if len(self.geometries) == 0:
raise Exception('no geometries')
return server.post(
'task_admin',
self.as_payload(),
replacements={
'slug': self.__challenge__.slug,
'identifier': self.identifier}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_task():",
"def create_task(self, name, value):\n pass",
"def create_task():\n client = RequestManager()\n client.set_method(\"POST\")\n client.set_endpoint(\"/projects/{0}/stories/{1}/tasks\".format(STORED_ID['project_id'], STORED_ID['story_id']))\n name = \"\".joi... | [
"0.8675896",
"0.75931495",
"0.7256835",
"0.71343005",
"0.7059578",
"0.70504224",
"0.70264506",
"0.7024704",
"0.69823843",
"0.69811654",
"0.695801",
"0.69416815",
"0.68903977",
"0.68586636",
"0.6837721",
"0.6830297",
"0.6803687",
"0.67863655",
"0.67849886",
"0.6761924",
"0.674... | 0.62833476 | 64 |
Update existing task on the server | def update(self, server):
return server.put(
'task_admin',
self.as_payload(),
replacements={
'slug': self.__challenge__.slug,
'identifier': self.identifier}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_task(self, task):\n create = task.id == 0\n\n xml = self._serialise_task(task)\n\n method = ['PUT','POST'][create]\n\n if create:\n url = \"%s/tasks?%s\" % \\\n (self._get_base_url(), self._get_url_params())\n else:\n url = \"%s/t... | [
"0.8158114",
"0.8152909",
"0.76661485",
"0.7663534",
"0.7616725",
"0.7550435",
"0.7534657",
"0.7525693",
"0.74830467",
"0.7400476",
"0.73755723",
"0.7304954",
"0.7256344",
"0.7224427",
"0.7218338",
"0.7215386",
"0.7203241",
"0.718519",
"0.7181675",
"0.7085396",
"0.70829463",
... | 0.6991943 | 24 |
Check if a task exists on the server | def exists(self, server):
try:
server.get(
'task',
replacements={
'slug': self.__challenge__.slug,
'identifier': self.identifier})
except Exception:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __check_if_task_exists(self, server_id):\n if server_id in self.__migrating_tasks.keys():\n return True\n return False",
"def exists_task(self, task):\n assert task, \"Must input a valid task name.\"\n return any(self.get_by_task(task))",
"def isTasksExists(request):... | [
"0.77683973",
"0.7662436",
"0.74845606",
"0.73977894",
"0.7334475",
"0.68549156",
"0.68336856",
"0.6772",
"0.67269367",
"0.6711562",
"0.67005736",
"0.6666161",
"0.6534565",
"0.64875007",
"0.6391127",
"0.6377171",
"0.6374866",
"0.63482434",
"0.63294256",
"0.6309257",
"0.629597... | 0.8097337 | 0 |
Retrieve a task from the server | def from_server(cls, server, slug, identifier):
task = server.get(
'task',
replacements={
'slug': slug,
'identifier': identifier})
return cls(**task) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_task(self):\n\n url='{url}/task'.format(url=config.SERVER_URL)\n\n try:\n res=request.urlopen(url,timeout=10).read()\n res=str(res,encoding='utf8')\n except Exception as e:\n check_server() # sleep until server is available\n try:\n ... | [
"0.79089105",
"0.77541333",
"0.7590145",
"0.73984325",
"0.7325193",
"0.73121446",
"0.72696733",
"0.7252774",
"0.7249014",
"0.72433484",
"0.7215614",
"0.7204756",
"0.71764857",
"0.7148466",
"0.7100719",
"0.7094087",
"0.70633936",
"0.7023238",
"0.69586605",
"0.6954439",
"0.6948... | 0.0 | -1 |
Create a task from JSON | def from_payload(cls, payload):
return cls(**payload) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_json(json):\n\n if \"description\" not in json or \"tags\" not in json or \"files\" not in json:\n raise InvalidJSONException(\"Task must have a description, a list of tags and a list of files\")\n\n if type(json[\"description\"]) != str:\n raise InvalidJSONException(\"... | [
"0.8003312",
"0.7318135",
"0.7193144",
"0.7155828",
"0.7070071",
"0.70066273",
"0.6857383",
"0.6823616",
"0.6789037",
"0.66410047",
"0.6638342",
"0.65754247",
"0.6503764",
"0.6498993",
"0.6407582",
"0.6403449",
"0.63990456",
"0.6354787",
"0.6262863",
"0.62520087",
"0.6243814"... | 0.0 | -1 |
Initializes a new MuJoCo environment. | def __init__(self,
model_path: str,
frame_skip: int,
camera_settings: Optional[Dict] = None,
):
self._seed()
if not os.path.isfile(model_path):
raise IOError(
'[MujocoEnv]: Model path does not exist: {}'.format(model_path))
self.frame_skip = frame_skip
self.sim_robot = MujocoSimRobot(
model_path,
camera_settings=camera_settings)
self.sim = self.sim_robot.sim
self.model = self.sim_robot.model
self.data = self.sim_robot.data
self.metadata = {
'render.modes': ['human', 'rgb_array', 'depth_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.mujoco_render_frames = False
self.init_qpos = self.data.qpos.ravel().copy()
self.init_qvel = self.data.qvel.ravel().copy()
observation, _reward, done, _info = self.step(np.zeros(self.model.nu))
assert not done
bounds = self.model.actuator_ctrlrange.copy()
act_upper = bounds[:, 1]
act_lower = bounds[:, 0]
# Define the action and observation spaces.
# HACK: MJRL is still using gym 0.9.x so we can't provide a dtype.
try:
self.action_space = spaces.Box(
act_lower, act_upper, dtype=np.float32)
if isinstance(observation, collections.Mapping):
self.observation_space = spaces.Dict({
k: spaces.Box(-np.inf, np.inf, shape=v.shape, dtype=np.float32) for k, v in observation.items()})
else:
self.obs_dim = np.sum([o.size for o in observation]) if type(observation) is tuple else observation.size
self.observation_space = spaces.Box(
-np.inf, np.inf, observation.shape, dtype=np.float32)
except TypeError:
# Fallback case for gym 0.9.x
self.action_space = spaces.Box(act_lower, act_upper)
assert not isinstance(observation, collections.Mapping), 'gym 0.9.x does not support dictionary observation.'
self.obs_dim = np.sum([o.size for o in observation]) if type(observation) is tuple else observation.size
self.observation_space = spaces.Box(
-np.inf, np.inf, observation.shape) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, env):\n gym.Wrapper.__init__(self, env)",
"def __init__(self, env):\n gym.Wrapper.__init__(self, env)",
"def __init__(self): \n\t\n\t # get the environment\n\t\tself.env = env()",
"def initialize():\n environment = Environment()\n environment.setup()",
"def __init... | [
"0.65531933",
"0.65531933",
"0.6540199",
"0.6425967",
"0.6125439",
"0.60250366",
"0.5981867",
"0.59326357",
"0.58881015",
"0.5858973",
"0.5796893",
"0.5779154",
"0.5775181",
"0.57644004",
"0.5762341",
"0.5751086",
"0.5751086",
"0.5721603",
"0.5721603",
"0.567534",
"0.56694514... | 0.5511559 | 43 |
Reset the robot degrees of freedom (qpos and qvel). Implement this in each subclass. | def reset_model(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\n self._position = TwoDV(0.0, 0.0)\n self._orient = TNavigator.START_ORIENTATION[self._mode]",
"def specific_reset(self) -> None:\n self.agent.specific_reset() # reset joints\n new_pos = self.agent.init_xyz\n new_pos[:2] = np.random.uniform(-0.01, 0.01, 2)\n ... | [
"0.6537879",
"0.6535229",
"0.64604867",
"0.64147246",
"0.6386366",
"0.6382191",
"0.6351365",
"0.62435204",
"0.623713",
"0.6203848",
"0.6164331",
"0.61403173",
"0.612164",
"0.61177164",
"0.6117006",
"0.60989344",
"0.6085719",
"0.6066662",
"0.60641676",
"0.60370797",
"0.6028802... | 0.0 | -1 |
Backwards compatibility with MJRL. | def mj_render(self):
self.render(mode='human') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self) -> None:",
"def moi(self):\n\n pass",
"def __call__(self):\n raise NotImplementedError",
"def __call__(self):\n\t\treturn",
"def use(self):",
"def support(self):",
"def lro(self) -> global___Snippet.Lro:",
"def regular(self):",
"def __call__():",
"def __call__():"... | [
"0.62065375",
"0.59999824",
"0.59971726",
"0.5977466",
"0.5968731",
"0.59595406",
"0.58379644",
"0.5770757",
"0.5765837",
"0.5765837",
"0.5765837",
"0.5765837",
"0.5765837",
"0.57506377",
"0.57506377",
"0.570763",
"0.5704474",
"0.5680616",
"0.5670139",
"0.5652243",
"0.5639114... | 0.0 | -1 |
Loads class labels at 'path' | def load_class_ck(path):
fp = open(path, "r",encoding="utf-8")
names = fp.read().split("\n")[:-1]
return names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_labels(self, pathLabel):\n self.pathLabel = pathLabel\n self.labelList = os.listdir(pathLabel)",
"def load_label(path: str) -> dict:\n if not os.path.exists(path):\n print(f\"Warning, try to load non-exist label {path}\")\n return None\n return np.load(path, allow_pickl... | [
"0.76263887",
"0.70822763",
"0.6987063",
"0.6917422",
"0.6886614",
"0.684222",
"0.6831526",
"0.67475176",
"0.67435664",
"0.6732817",
"0.66995424",
"0.6691952",
"0.6691952",
"0.6657494",
"0.66031843",
"0.6593739",
"0.65641505",
"0.649268",
"0.6491007",
"0.6329085",
"0.6310958"... | 0.6649412 | 14 |
The function reads the antenna positions (N_ant antennas) from the file given. | def from_antenna_config(filename, z, nu=None):
antll = np.loadtxt(filename)
Re = 6.371e6 # in m
pp = np.pi/180
if not nu: nu = c2t.z_to_nu(z) # MHz
antxyz = np.zeros((antll.shape[0],3)) # in m
antxyz[:,0] = Re*np.cos(antll[:,1]*pp)*np.cos(antll[:,0]*pp)
antxyz[:,1] = Re*np.cos(antll[:,1]*pp)*np.sin(antll[:,0]*pp)
antxyz[:,2] = Re*np.sin(antll[:,1]*pp)
del pp, antll
N_ant = antxyz.shape[0]
Nbase = np.zeros((N_ant*(N_ant-1)/2,3))
pair_comb = itertools.combinations(xrange(N_ant), 2)
pair_comb = list(pair_comb)
lam = c_light/(nu*1e6)/1e2 # in m
for i in xrange(Nbase.shape[0]):
ii,jj = pair_comb[i]
ux = (antxyz[ii,0]-antxyz[jj,0])/lam
uy = (antxyz[ii,1]-antxyz[jj,1])/lam
uz = (antxyz[ii,2]-antxyz[jj,2])/lam
Nbase[i,:] = ux,uy,uz
return Nbase, N_ant | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_positions():\n return np.genfromtxt(\"POSITIONS.OUT\").transpose()",
"def readInput(in_file_name):\n in_file = open(in_file_name, 'r')\n positions = []\n samples = []\n M = []; P = [];\n MC = []; PC = [];\n while True:\n line = in_file.readline()\n if not line: break\n ... | [
"0.6724647",
"0.6426691",
"0.6014739",
"0.59488297",
"0.59237134",
"0.5912095",
"0.5865451",
"0.5829912",
"0.58188653",
"0.58121365",
"0.58050466",
"0.5768979",
"0.5765536",
"0.5717999",
"0.5706781",
"0.56984544",
"0.5671126",
"0.565585",
"0.5651771",
"0.56221503",
"0.5617779... | 0.56716186 | 16 |
The rotation of the earth over the observation times makes changes the part of the sky measured by each antenna. | def earth_rotation_effect(Nbase, slice_num, int_time, declination=30.):
p = np.pi/180.
delta = p*declination
k = slice_num
HA =-15.0*p*(k-1)*int_time/(3600.0) - np.pi/180.0*90.0 + np.pi/180.0*360.0
new_Nbase = np.zeros(Nbase.shape)
new_Nbase[:,0] = np.sin(HA)*Nbase[:,0] + np.cos(HA)*Nbase[:,1]
new_Nbase[:,1] = -1.0*np.sin(delta)*np.cos(HA)*Nbase[:,0] + np.sin(delta)*np.sin(HA)*Nbase[:,1] + np.cos(delta)*Nbase[:,2]
new_Nbase[:,2] = np.cos(delta)*np.cos(HA)*Nbase[:,0] - np.cos(delta)*np.sin(HA)*Nbase[:,1] + np.sin(delta)*Nbase[:,2]
return new_Nbase | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotate_orbit(self):\n try:\n ang = self.orbit_speed * self.time_scale / self.refresh_rate\n self.obj.rotate(angle=ang, axis=vector(0, 1, 0), origin=self.star.obj.pos)\n self.sum_ang += ang\n except ZeroDivisionError:\n print(\"ERROR: REFRESH_RATE is 0\"... | [
"0.6289923",
"0.62318367",
"0.6067944",
"0.60519284",
"0.59558403",
"0.59422225",
"0.5937349",
"0.5936226",
"0.59156203",
"0.5899485",
"0.5844154",
"0.5770054",
"0.576213",
"0.5754233",
"0.57514757",
"0.5723362",
"0.5705267",
"0.56774634",
"0.5661177",
"0.5657915",
"0.5656137... | 0.6019258 | 4 |
The radio telescopes observe the sky for 'total_int_time' hours each day. The signal is recorded every 'int_time' seconds. | def daily_observation(z, ncells, filename, total_int_time=4., int_time=10., boxsize=None, declination=30.):
Nbase, N_ant = from_antenna_config(filename, z)
uv_map0 = get_uv_coverage(Nbase, z, ncells, boxsize=boxsize)
uv_map = np.zeros(uv_map0.shape)
tot_num_obs = int(3600.*total_int_time/int_time)
for i in xrange(tot_num_obs-1):
new_Nbase = earth_rotation_effect(Nbase, i+1, int_time, declination=declination)
uv_map1 = get_uv_coverage(new_Nbase, z, ncells, boxsize=boxsize)
uv_map += uv_map1
print i
uv_map = (uv_map+uv_map1)/tot_num_obs
return uv_map, N_ant | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def set_integration_time(self, int_time: int):\n return await self.hw_device.integration_time(int_time)",
"def setIntegrationTime(self,t_int):\n \n acc_len = self._adcClock*1e6*t_int/(1024.0) \n if acc_len > 65536:\n raise(\"Integration time is too long:\",t_int)... | [
"0.5954411",
"0.5676104",
"0.55020225",
"0.52751565",
"0.49494395",
"0.49394286",
"0.4906087",
"0.4901808",
"0.48571083",
"0.48567733",
"0.4848392",
"0.48170355",
"0.48030984",
"0.47985277",
"0.47943923",
"0.4758018",
"0.47353464",
"0.47334984",
"0.472768",
"0.47261432",
"0.4... | 0.0 | -1 |
It calculated the uv_map for the uvcoverage. | def get_uv_coverage(Nbase, z, ncells, boxsize=None):
if not boxsize: boxsize = c2t.conv.LB
uv_map = np.zeros((ncells,ncells))
theta_max = c2t.conv.LB/c2t.z_to_cdist(z)
for p in xrange(Nbase.shape[0]):
i,j,k = np.round(Nbase[p,0]*theta_max),np.round(Nbase[p,1]*theta_max),np.round(Nbase[p,2]*theta_max)
if np.abs(i)<ncells:
if np.abs(j)<ncells:
uv_map[int(i),int(j)] += 1
return uv_map | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uvmap(self, p):\n pass",
"def uvmap(self, p):\n # bottom left corner of the plane\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\n dif_vector = p - p00\n u = np.dot(dif_vector, self.n0) / self.sx\n v = np.dot(dif_vector, self.n1) / self.sy\... | [
"0.7532845",
"0.6147069",
"0.59362704",
"0.59166545",
"0.59061474",
"0.5892625",
"0.55217695",
"0.5503293",
"0.54990137",
"0.5495749",
"0.54743665",
"0.5441941",
"0.54397714",
"0.54297936",
"0.5418282",
"0.53442216",
"0.5343465",
"0.5342541",
"0.5336867",
"0.5311103",
"0.5292... | 0.6111474 | 2 |
It calculates the rms of the noise added by the interferrometers of ska. | def kanan_noise_image_ska(z, uv_map, depth_mhz, obs_time, N_ant_ska=564.):
nuso = 1420.0/(1.0 + z)
delnu = depth_mhz*1e3 # in kHz
effective_baseline = np.sum(uv_map)
T_sys_atnu300MHz= 60.0 #K
T_sys = T_sys_atnu300MHz*(300.0/nuso)**2.55
ant_radius_ska = 35./2. #in m
A_ant_ska = np.pi*ant_radius_ska*ant_radius_ska
sigma = np.sqrt(2.0)*KB_SI*(T_sys/A_ant_ska)/np.sqrt((depth_mhz*1e6)*(obs_time*3600.0))/janskytowatt*1e3/np.sqrt(N_ant_ska*N_ant_ska/2.0) ## in mJy
rms_noi = np.sqrt(2.0)*KB_SI/janskytowatt/1e3/600. *(T_sys/100.0)*(100.0/A_ant_ska)* np.sqrt(1000.0/delnu)*np.sqrt(100.0/obs_time)*1e3
sigma *= 1e3 #in muJy
rms_noi *= 1e3
print 'Expected: rms in image in muJy per beam for full =', sigma
print 'Effective baseline =', sigma*np.sqrt(N_ant_ska*N_ant_ska/2.0)/np.sqrt(effective_baseline), 'm'
print 'Calculated: rms in the visibility =', rms_noi, 'muJy'
return sigma, rms_noi | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_desired_noise_rms(clean_rms, snr):\n a = float(snr) / 20\n noise_rms = clean_rms / (10 ** a)\n return noise_rms",
"def noiseReduction(self):\n pass",
"def __mix_with_snr(self, sig_spk, sig_noise, need_snr):\n\n # Calc SNR\n pow_sp = np.sum((sig_spk) ** 2) / float(len... | [
"0.7203031",
"0.7082178",
"0.6568871",
"0.6568871",
"0.6404555",
"0.6361032",
"0.6209166",
"0.6132606",
"0.61150664",
"0.60341376",
"0.6025671",
"0.60177475",
"0.6004052",
"0.6003546",
"0.5993322",
"0.5989995",
"0.5975633",
"0.5961862",
"0.59155107",
"0.59027416",
"0.5901672"... | 0.59576935 | 18 |
In the initialization of the blanc canvas the number of rows and columns can be defined, finally the canvas is placed into the parent frame. | def __init__(self, parent, rows=1, columns=1, set_grid_propagate=False,
*args, **kwargs):
super().__init__(parent, highlightthickness=0, *args, **kwargs)
self.grid_propagate(set_grid_propagate)
self.set_num_of_rows(rows)
self.set_num_of_columns(columns)
self.grid(sticky="NESW") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_canvas(self):\n # create frame to contain canvas\n self.world_container = tk.Frame(self,\n width = self.world_size[1],\n height = self.world_size[0])\n self.world_container.grid(row = 1, column = 0, sticky ... | [
"0.7390701",
"0.7325227",
"0.7284718",
"0.7152517",
"0.7130581",
"0.7130581",
"0.7130581",
"0.70996016",
"0.6822051",
"0.6757563",
"0.67494226",
"0.66495013",
"0.66449696",
"0.6612262",
"0.66097903",
"0.65810424",
"0.6549738",
"0.6528398",
"0.6521471",
"0.64550036",
"0.644386... | 0.6334319 | 26 |
Approximate the 95% confidence interval for Student's T distribution. Given the degrees of freedom, returns an approximation to the 95% confidence interval for the Student's T distribution. | def tdist95conf_level(df):
df = int(round(df))
highest_table_df = len(_T_DIST_95_CONF_LEVELS)
if df >= 200:
return 1.960
if df >= 100:
return 1.984
if df >= 80:
return 1.990
if df >= 60:
return 2.000
if df >= 50:
return 2.009
if df >= 40:
return 2.021
if df >= highest_table_df:
return _T_DIST_95_CONF_LEVELS[highest_table_df - 1]
return _T_DIST_95_CONF_LEVELS[df] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def confidence_at_95tpr(self):\r\n\r\n return self.confidence_at_tpr(0.95)",
"def t_confidence_Interval_Difference_Of_Means(xSamples, ySamples, confidence):\n try:\n if len(xSamples) >= 30 or len(ySamples) >= 30:\n raise sampleSizeError(\"Should use normal distribution instead. m or n... | [
"0.7058479",
"0.6177722",
"0.60270077",
"0.601931",
"0.58983326",
"0.58310044",
"0.57847005",
"0.5780554",
"0.5745698",
"0.5712912",
"0.5690209",
"0.56681216",
"0.56415606",
"0.561999",
"0.56135404",
"0.56095594",
"0.55160135",
"0.54769456",
"0.547189",
"0.5418613",
"0.540857... | 0.53884614 | 23 |
Find the pooled sample variance for two samples. | def pooled_sample_variance(sample1, sample2):
deg_freedom = len(sample1) + len(sample2) - 2
mean1 = statistics.mean(sample1)
squares1 = ((x - mean1) ** 2 for x in sample1)
mean2 = statistics.mean(sample2)
squares2 = ((x - mean2) ** 2 for x in sample2)
return (math.fsum(squares1) + math.fsum(squares2)) / float(deg_freedom) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def variance(self):\r\n\t\t_mean = sum(self.sample)/len(self.sample)\r\n\t\treturn sum(map(lambda x: (x - _mean)**2, self.sample))/(len(self.sample) - 1)",
"def variance( values, sample=False ):\n mean_val = mean_value( values )\n n_val = len( values ) -1 if sample else len( values )\n return sum( [ j**... | [
"0.69535667",
"0.68496686",
"0.67732096",
"0.6738547",
"0.67180645",
"0.65582496",
"0.6516183",
"0.64949",
"0.6486372",
"0.6415831",
"0.6393349",
"0.639173",
"0.63470465",
"0.63140863",
"0.6311792",
"0.6310086",
"0.6282926",
"0.62156796",
"0.62076354",
"0.61959153",
"0.604445... | 0.80888563 | 0 |
Calculate a ttest score for the difference between two samples. | def tscore(sample1, sample2):
if len(sample1) != len(sample2):
raise ValueError("different number of values")
error = pooled_sample_variance(sample1, sample2) / len(sample1)
diff = statistics.mean(sample1) - statistics.mean(sample2)
return diff / math.sqrt(error * 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ttest(array1, array2):\n diff = np.mean(array1) - np.mean(array2)\n if diff < c.cart_p60:\n return c.low_score\n if array1.size <= 1 or array2.size <= 1:\n return min(diff, c.single_item_cart_max)\n return 1 - ttest_ind(array1, array2, equal_var=False).pvalue\n # return diff",
"d... | [
"0.75622785",
"0.6732271",
"0.67147094",
"0.67101526",
"0.66661763",
"0.64419353",
"0.6416758",
"0.64082766",
"0.63968855",
"0.6324951",
"0.6282402",
"0.6253952",
"0.6186208",
"0.61227715",
"0.6105249",
"0.60951906",
"0.5997991",
"0.59836954",
"0.59664416",
"0.5946647",
"0.59... | 0.7724763 | 0 |
Determine whether two samples differ significantly. This uses a Student's twosample, twotailed ttest with alpha=0.95. | def is_significant(sample1, sample2):
deg_freedom = len(sample1) + len(sample2) - 2
critical_value = tdist95conf_level(deg_freedom)
t_score = tscore(sample1, sample2)
return (abs(t_score) >= critical_value, t_score) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ttest_review(sample_1, sample_2, alpha=.05):\n\n result = stats.ttest_ind(sample_1, sample_2)\n crit_val, p_val = result\n \n ## Creating interpretation based on p-value results.\n\n if p_val < .05:\n print(f'The feature is statistically significant with a p-value of {p_val}.')\n\n els... | [
"0.6815539",
"0.6802423",
"0.67800075",
"0.67102456",
"0.66998667",
"0.6637655",
"0.66326714",
"0.6597813",
"0.6578872",
"0.6518927",
"0.64484495",
"0.64479405",
"0.63393015",
"0.6331243",
"0.61787146",
"0.6156587",
"0.6153929",
"0.61489004",
"0.61462283",
"0.61424893",
"0.61... | 0.6690653 | 5 |
Get status summary of given transport node. | def get_aggregation_status(cls, client_obj, get_aggregation_status=None):
attr_map = {'node_uuid': 'uuid',
'bfd_admin_down_count': 'admin_down_count',
'bfd_init_count': 'init_count',
'bfd_up_count': 'up_count',
'bfd_down_count': 'down_count'}
node_id = client_obj.id_
# TODO(gangarm): Check if we can use a better name in product sdk for
# param_1_id, which is essentially node id.
client_class_obj = gettransportnodestatus.GetTransportNodeStatus(
connection_object=client_obj.connection, param_1_id=node_id)
status_schema_object = client_class_obj.read()
status_schema_dict = status_schema_object.get_py_dict_from_object()
mapped_dict = utilities.map_attributes(attr_map, status_schema_dict)
result_dict = dict()
result_dict['response'] = mapped_dict
result_dict['response_data'] = dict()
result_dict['response_data']['status_code'] = (
client_class_obj.last_calls_status_code)
return result_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNodeStatus(self,node):\n data = self.connect('get','nodes/%s/status' % (node),None)\n return data",
"def getNodeTaskStatusByUPID(self,node,upid):\n data = self.connect('get','nodes/%s/tasks/%s/status' % (node,upid),None)\n return data",
"def status(self):\n url = API_P... | [
"0.7329152",
"0.6466141",
"0.6326778",
"0.63179845",
"0.6115346",
"0.608754",
"0.60856014",
"0.6035681",
"0.6000012",
"0.59930164",
"0.59930164",
"0.5987499",
"0.5987269",
"0.5976228",
"0.596927",
"0.5969141",
"0.5904546",
"0.5899778",
"0.5893478",
"0.5890255",
"0.58680993",
... | 0.0 | -1 |
return autsizeable field names in idfobject | def autosize_fieldname(idfobject):
# undocumented stuff in this code
return [
fname
for (fname, dct) in zip(idfobject.objls, idfobject["objidd"])
if "autosizable" in dct
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def field_names(self):\n ...",
"def objectFields(self):\n raise NotImplementedError",
"def fields(self):",
"def _fields_names(cls) -> List:\n return list(field.name for field in dataclasses.fields(cls))",
"def fields(self):\n ...",
"def get_field_names(self):\n return {rv[0... | [
"0.7096624",
"0.7052038",
"0.68935066",
"0.66643006",
"0.6553258",
"0.6494789",
"0.6485936",
"0.6427995",
"0.64223516",
"0.63584894",
"0.6328418",
"0.63140696",
"0.62944096",
"0.62799215",
"0.6263371",
"0.62606794",
"0.6165774",
"0.6162808",
"0.61518234",
"0.611477",
"0.61031... | 0.765945 | 0 |
Checks whether the given ISBN10 code is valid. >>> isISBN10('9971502100') True >>> isISBN10('9971502108') False | def isISBN10(code):
# helper function for computing ISBN-10 check digit
def check_digit(code):
# compute check digit
check = sum((i + 1) * int(code[i]) for i in range(9)) % 11
# convert check digit into its string representation
return 'X' if check == 10 else str(check)
# check whether given code is a string
if not isinstance(code, str):
return False
# check whether given code contains 10 characters
if len(code) != 10:
return False
# check whether first nine characters of given code are digits
if not code[:9].isdigit():
return False
# check the check digit
return check_digit(code) == code[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isISBN(code):\n if not (\n isinstance(code, str) and # code must be a string\n len(code) == 10 and # code must contain 10 characters\n code[:9].isdigit() # first nine characters must be digits\n ):\n return False\n\n # check the check digit\n return check... | [
"0.82796675",
"0.8265154",
"0.7875872",
"0.76414096",
"0.7556362",
"0.734542",
"0.73319346",
"0.72045577",
"0.7138764",
"0.7138109",
"0.704493",
"0.64504737",
"0.6407236",
"0.6328351",
"0.63012135",
"0.6227752",
"0.6151876",
"0.60880727",
"0.60821617",
"0.60790056",
"0.601290... | 0.8820598 | 0 |
Checks whether the given ISBN13 code is valid. >>> isISBN13('9789743159664') True >>> isISBN13('9787954527409') False >>> isISBN13('8799743159665') False | def isISBN13(code):
# helper function for computing ISBN-10 check digit
def check_digit(code):
# compute check digit
check = sum((3 if i % 2 else 1) * int(code[i]) for i in range(12))
# convert check digit into a single digit
return str((10 - check) % 10)
# check whether given code is a string
if not isinstance(code, str):
return False
# check whether given code contains 10 characters
if len(code) != 13:
return False
# check whether first nine characters of given code are digits
if not code[:12].isdigit():
return False
# check the check digit
return check_digit(code) == code[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_isbn_13(isbn13):\r\n isbn13 = re.sub(r'[^0-9X]', '', isbn13.replace('x', 'X'))\r\n if len(isbn13) != 13: return False\r\n if isbn13[0:3] not in ('978', '979'): return False\r\n return False if isbn_13_check_digit(isbn13[:-1]) != isbn13[-1] else True",
"def isISBN(code, isbn13=True):\n\n ret... | [
"0.8294502",
"0.8156061",
"0.7813687",
"0.7593365",
"0.7539352",
"0.7096975",
"0.70109516",
"0.6998053",
"0.6760535",
"0.6702344",
"0.6442007",
"0.64231825",
"0.6403078",
"0.6313602",
"0.6305555",
"0.6260889",
"0.6107894",
"0.5969835",
"0.5896946",
"0.57390374",
"0.56742215",... | 0.86895674 | 0 |
>>> isISBN('9789027439642', False) False >>> isISBN('9789027439642', True) True >>> isISBN('9789027439642') True >>> isISBN('080442957X') False >>> isISBN('080442957X', False) True | def isISBN(code, isbn13=True):
return isISBN13(code) if isbn13 else isISBN10(code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_isbn(val):\n if is_isbn10(val) or is_isbn13(val):\n if val[0:3] in [\"978\", \"979\"] or not is_ean13(val):\n return True\n return False",
"def isISBN(code):\n if not (\n isinstance(code, str) and # code must be a string\n len(code) == 10 and # code must co... | [
"0.7865637",
"0.7720685",
"0.7428631",
"0.7180673",
"0.71515095",
"0.7052291",
"0.68789357",
"0.6845327",
"0.6841594",
"0.6841162",
"0.6837004",
"0.6813746",
"0.68048567",
"0.675236",
"0.66869426",
"0.6474136",
"0.64726096",
"0.64508146",
"0.640185",
"0.6327851",
"0.621259",
... | 0.7591935 | 2 |
>>> codes = ['0012345678', '0012345679', '9971502100', '080442957X', 5, True, 'The Practice of Computing Using Python', '9789027439642', '5486948320146'] >>> areISBN(codes) [False, True, True, True, False, False, False, True, False] >>> areISBN(codes, True) [False, False, False, False, False, False, False, True, False] >>> areISBN(codes, False) [False, True, True, True, False, False, False, False, False] | def areISBN(codes, isbn13=None):
# initialize list of checks
checks = []
# construct list of checks
for code in codes:
if isinstance(code, str):
if isbn13 is None:
checks.append(isISBN(code, len(code) == 13))
else:
checks.append(isISBN(code, isbn13))
else:
checks.append(False)
# return list of checks
return checks | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_isbn(val):\n if is_isbn10(val) or is_isbn13(val):\n if val[0:3] in [\"978\", \"979\"] or not is_ean13(val):\n return True\n return False",
"def isISBN(code, isbn13=True):\n\n return isISBN13(code) if isbn13 else isISBN10(code)",
"def isISBN(code):\n if not (\n isinst... | [
"0.74519074",
"0.72815156",
"0.7090671",
"0.65742284",
"0.65578085",
"0.6463269",
"0.63166803",
"0.6275632",
"0.6265059",
"0.62025166",
"0.6028817",
"0.59755796",
"0.58285195",
"0.5798127",
"0.5781443",
"0.5775947",
"0.570381",
"0.563113",
"0.5504642",
"0.54982454",
"0.548243... | 0.8204821 | 0 |
Calculates a one's complement integer from the given input value's bits | def ones_complement(x, bits=16):
return x ^ ((1 << bits) - 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ones_complement(val):\n #mask = (1 << val.bit_length()) - 1\n #return int(hex(val ^ mask), 16)\n b = bin(val)\n b = b.replace('0', 'x')\n b = b.replace('1', '0')\n b = b.replace('x', '1')\n b = b.replace('1b', '0b')\n return int(b, 2)",
"def complement(... | [
"0.80567867",
"0.7861335",
"0.75720483",
"0.7485613",
"0.7387961",
"0.73278314",
"0.7293334",
"0.70973384",
"0.6932238",
"0.6895889",
"0.68579566",
"0.6638871",
"0.663495",
"0.66179526",
"0.6587711",
"0.6580346",
"0.6573302",
"0.6573302",
"0.6572931",
"0.6572931",
"0.6572931"... | 0.75856197 | 2 |
Calculates a two's complement integer from the given input value's bits | def twos_complement(input_value, num_bits=16):
mask = 2 ** (num_bits - 1)
return -(input_value & mask) + (input_value & ~mask) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def twos_complement(n, bits):\n if n < 0 or n >= 2**bits:\n raise ValueError\n\n return 2**bits - n",
"def twos_complement(val, bits):\n if (val & (1 << (bits - 1))) != 0: # if sign bit is set e.g., 8bit: 128-255\n val = val - (1 << bits) # compute negative value\n return val ... | [
"0.773702",
"0.7683835",
"0.76752746",
"0.7462103",
"0.74167454",
"0.7336416",
"0.70802414",
"0.70657045",
"0.70034766",
"0.6954941",
"0.69006544",
"0.68687546",
"0.676691",
"0.67314565",
"0.67230797",
"0.67230797",
"0.67230797",
"0.6720881",
"0.6720881",
"0.6685405",
"0.6657... | 0.79249084 | 0 |
Transfer models to target port | def transfer(self, target_port: Port, evaluator: Evaluator, config_uids: List[int] = None) -> None:
if target_port.name not in self.transfer_defs:
print(f"No transfer definition found for target port '{target_port.name}'")
return
# transfer definitions for specified target port
tds = self.transfer_defs[target_port.name]
output_dir = os.path.join(script_dir, os.pardir, "output")
training_type = "transfer"
print(f"TRANSFERRING MODELS TO TARGET PORT '{target_port.name}'")
if config_uids is not None:
print(f"Transferring configs -> {config_uids} <-")
window_width = 50
num_epochs = 25
train_lr = 0.01
fine_num_epochs = 20
fine_tune_lr = 1e-5
batch_size = 1024
# skip port if fully transferred
num_not_transferred = 0
for td in tds:
for config in self.transfer_configs:
if not self._is_transferred(target_port.name, td.base_port_name, config.uid):
# print(f"Not transferred: {td.base_port_name} -> {target_port.name} ({config.uid})")
num_not_transferred += 1
num_transfers = len(tds) * len(self.transfer_configs)
print(f"Transferred count {num_transfers - num_not_transferred}/{num_transfers}")
if num_not_transferred == 0:
print(f"All transfers done for target port '{target_port.name}': Skipping")
return
X_ts, y_ts = load_data(target_port, window_width)
baseline = mean_absolute_error(y_ts, np.full_like(y_ts, np.mean(y_ts)))
evaluator.set_naive_baseline(target_port, baseline)
print(f"Naive baseline: {baseline}")
# X_train_orig, X_test_orig, y_train_orig, y_test_orig = train_test_split(X_ts, y_ts, test_size=0.2,
# random_state=42, shuffle=False)
# train_optimizer = Adam(learning_rate=train_lr)
# fine_tune_optimizer = Adam(learning_rate=fine_tune_lr)
for td in tds:
print(f".:'`!`':. TRANSFERRING PORT {td.base_port_name} TO {td.target_port_name} .:'`!`':.")
print(f"- - Epochs {num_epochs} </> </> Learning rate {train_lr} - -")
print(f"- - Window width {window_width} </> Batch size {batch_size} - -")
# print(f"- - Number of model's parameters {num_total_trainable_parameters(model)} device {device} - -")
base_port = self.pm.find_port(td.base_port_name)
if base_port is None:
raise ValueError(f"Unable to associate port with port name '{td.base_port_name}'")
# model = inception_time(input_shape=(window_width, 37))
# print(model.summary())
# apply transfer config
for config in self.transfer_configs:
if config_uids is not None and config.uid not in config_uids:
continue
if self._is_transferred(target_port.name, td.base_port_name, config.uid):
print(f"Skipping config {config.uid}")
continue
print(f"\n.:'':. APPLYING CONFIG {config.uid} ::'':.")
print(f"-> -> {config.desc} <- <-")
print(f"-> -> nth_subset: {config.nth_subset} <- <-")
print(f"-> -> trainable layers: {config.train_layers} <- <-")
_, _, start_time, _, _ = decode_keras_model(os.path.split(td.base_model_path)[1])
model_file_name = encode_keras_model(td.target_port_name, start_time, td.base_port_name, config.uid)
file_path = os.path.join(output_dir, "model", td.target_port_name, model_file_name)
X_train_orig, X_test_orig, y_train_orig, y_test_orig = train_test_split(X_ts, y_ts, test_size=0.2,
random_state=42, shuffle=False)
train_optimizer = Adam(learning_rate=train_lr)
fine_tune_optimizer = Adam(learning_rate=fine_tune_lr)
checkpoint = ModelCheckpoint(file_path, monitor='val_mae', mode='min', verbose=2, save_best_only=True)
early = EarlyStopping(monitor="val_mae", mode="min", patience=10, verbose=2)
redonplat = ReduceLROnPlateau(monitor="val_mae", mode="min", patience=3, verbose=2)
callbacks_list = [checkpoint, early, redonplat]
# optimizer = Adam(learning_rate=lr)
#
# # configure model
# model.compile(optimizer=optimizer, loss="mse", metrics=["mae"])
# load base model
model = load_model(td.base_model_path)
# if config.uid == 0:
# print(model.summary())
# else:
# print(model.summary())
# del model
X_train = X_train_orig
X_test = X_test_orig
y_train = y_train_orig
y_test = y_test_orig
# apply transfer configuration
if config.nth_subset > 1:
if X_train.shape[0] < config.nth_subset:
print(f"Unable to apply nth-subset. Not enough data")
X_train = X_train_orig[0::config.nth_subset]
X_test = X_test_orig[0::config.nth_subset]
y_train = y_train_orig[0::config.nth_subset]
y_test = y_test_orig[0::config.nth_subset]
print(f"Orig shape: {X_train_orig.shape} {config.nth_subset} th-subset shape: {X_train.shape}")
print(f"Orig shape: {X_test_orig.shape} {config.nth_subset} th-subset shape: {X_test.shape}")
print(f"Orig shape: {y_train_orig.shape} {config.nth_subset} th-subset shape: {y_train.shape}")
print(f"Orig shape: {y_test_orig.shape} {config.nth_subset} th-subset shape: {y_test.shape}")
modified = False
# freeze certain layers
for layer in model.layers:
if layer.name not in config.train_layers:
modified = True
print(f"setting layer {layer.name} to False")
layer.trainable = False
else:
print(f"layer {layer.name} stays True")
if modified:
print(f"modified. compiling")
# re-compile
model.compile(optimizer=train_optimizer, loss="mse", metrics=["mae"])
# trainable_count = int(np.sum([K.count_params(p) for p in set(model.trainable_weights)]))
# non_trainable_count = int(np.sum([K.count_params(p) for p in set(model.non_trainable_weights)]))
trainable_count = count_params(model.trainable_weights)
non_trainable_count = count_params(model.non_trainable_weights)
print(f"Total params: {trainable_count + non_trainable_count}")
print(f"Trainable params: {trainable_count}")
print(f"Non trainable params: {non_trainable_count}")
# transfer model
result = model.fit(X_train, y_train, epochs=num_epochs, batch_size=batch_size, verbose=2,
validation_data=(X_test, y_test), callbacks=callbacks_list)
train_mae = result.history["mae"]
val_mae = result.history["val_mae"]
gc.collect()
tune_result = None
tune_train_mae = None
tune_val_mae = None
if config.tune:
print(f"Fine-Tuning transferred model")
# apply fine-tuning: unfreeze all but batch-normalization layers!
for layer in model.layers:
if not layer.name.startswith("batch_normalization"):
layer.trainable = True
model.compile(optimizer=fine_tune_optimizer, loss="mse", metrics=["mae"])
# print(f"model for fine tuning")
# print(model.summary())
tune_result = model.fit(X_train, y_train, epochs=fine_num_epochs, batch_size=batch_size, verbose=2,
validation_data=(X_test, y_test), callbacks=callbacks_list)
tune_train_mae = tune_result.history["mae"]
tune_val_mae = tune_result.history["val_mae"]
model.load_weights(file_path)
# set evaluation
def _compute_mae(_val_mae: List[float], _tune_val_mae: List[float]) -> float:
if _tune_val_mae is not None:
_val_mae = _val_mae + _tune_val_mae
return min(val_mae)
evaluator.set_mae(target_port, start_time, _compute_mae(val_mae, tune_val_mae), base_port, config.uid)
y_pred = model.predict(X_test)
grouped_mae = evaluator.group_mae(y_test, y_pred)
evaluator.set_mae(target_port, start_time, grouped_mae, base_port, config.uid)
# save history
history_file_name = encode_history_file(training_type, target_port.name, start_time, td.base_port_name,
config.uid)
history_path = os.path.join(output_dir, "data", target_port.name, history_file_name)
np.save(history_path, [result.history, tune_result.history if tune_result else None])
# plot history
plot_dir = os.path.join(output_dir, "plot")
plot_history(train_mae, val_mae, plot_dir, target_port.name, start_time, training_type,
td.base_port_name, config.uid, tune_train_mae, tune_val_mae)
# evaluator.plot_grouped_mae(target_port, training_type, start_time, config.uid)
plot_predictions(y_pred, y_test, plot_dir, target_port.name, start_time, training_type,
td.base_port_name, config.uid)
self.set_transfer(target_port.name, td.base_port_name, config.uid)
del checkpoint, early, redonplat
del X_train_orig, X_test_orig, y_train_orig, y_test_orig, model, X_train, y_train, X_test, y_test
gc.collect()
tf.keras.backend.clear_session()
gc.collect()
del X_ts, y_ts | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deploy_to_device(self):\n if self.device_ids is not None and len(self.device_ids) > 1:\n if not isinstance(self.model, torch.nn.DataParallel):\n self.model = torch.nn.DataParallel(self.model, self.device_ids)\n\n self.model = self.model.to(self.device)\n self.crit... | [
"0.60630095",
"0.60588175",
"0.57406735",
"0.56002295",
"0.551898",
"0.55181533",
"0.5453672",
"0.5411719",
"0.5400127",
"0.53960764",
"0.538731",
"0.53615785",
"0.53615785",
"0.5356729",
"0.53435755",
"0.5335418",
"0.5325586",
"0.5305902",
"0.52706647",
"0.52651966",
"0.5254... | 0.6467971 | 0 |
Generate TransferDefinitions based on transferconfig.json, containing those ports that have a base training for transferring to another port | def _generate_transfers(self) -> Dict[str, List[TransferDefinition]]:
config = read_json(self.config_path)
transfer_defs = {}
ports = list(config["ports"])
permutations = list(itertools.permutations(ports, r=2))
# for pair in _permute(config["ports"]):
for pair in permutations:
base_port, target_port = self.pm.find_port(pair[0]), self.pm.find_port(pair[1])
if target_port is None:
raise ValueError(f"No port found: Unable to transfer from base-port with name '{base_port.name}'")
if target_port is None:
raise ValueError(f"No port found: Unable to transfer to target-port with name '{pair[1]}'")
trainings = self.pm.load_trainings(base_port, self.output_dir, self.routes_dir, training_type="base")
# print(f"loaded trainings. base port {base_port.name}:\n{trainings.keys()}")
if len(trainings.keys()) < 1:
print(f"No base-training found for port '{base_port.name}'. Skipping")
continue
training = list(trainings.values())[-1][0]
# print(f"training ({len(trainings.values())}): {training}")
# print(f"Pair {base_port.name} ({len(trainings)} base-trains) -> {target_port.name}. "
# f"Using latest at '{training.start_time}'")
verify_output_dir(self.output_dir, target_port.name)
td = TransferDefinition(base_port_name=base_port.name,
base_model_path=training.model_path,
target_port_name=target_port.name,
target_routes_dir=os.path.join(self.routes_dir, target_port.name),
target_model_dir=os.path.join(self.output_dir, "model", target_port.name),
target_output_data_dir=os.path.join(self.output_dir, "data", target_port.name),
target_plot_dir=os.path.join(self.output_dir, "plot", target_port.name),
target_log_dir=os.path.join(self.output_dir, "log", target_port.name))
name = target_port.name
if name in transfer_defs:
transfer_defs[target_port.name].append(td)
else:
transfer_defs[target_port.name] = [td]
return transfer_defs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transfer(self, target_port: Port, evaluator: Evaluator, config_uids: List[int] = None) -> None:\n if target_port.name not in self.transfer_defs:\n print(f\"No transfer definition found for target port '{target_port.name}'\")\n return\n # transfer definitions for specified ta... | [
"0.6021851",
"0.5251869",
"0.51448715",
"0.5136205",
"0.5126871",
"0.5095791",
"0.50636524",
"0.49946162",
"0.49695787",
"0.49350056",
"0.49320048",
"0.49314785",
"0.4922587",
"0.48967493",
"0.48889312",
"0.4869051",
"0.48633268",
"0.4862456",
"0.4857697",
"0.484664",
"0.4846... | 0.8338399 | 0 |
Initialization of each point | def __init__(self, p0: Point, p1: Point, c0: Point = None, c1: Point = None) -> None:
self.p0 = p0
self.p1 = p1
self.c0 = c0 if c0 is not None else p0
self.c1 = c1 if c1 is not None else p1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, points):\n self.points = points\n self.init()",
"def __init__(self, pts=[]):\n self.set_points(pts)",
"def __init__(self, points):\n\t\tself.points = points",
"def __init__(self, num_points=5000):\n self.num_points = num_points\n\n # All walks start at (0... | [
"0.78019327",
"0.74978656",
"0.74227774",
"0.71523833",
"0.71523833",
"0.71206594",
"0.7075273",
"0.70572877",
"0.70357925",
"0.6961247",
"0.69041634",
"0.68821687",
"0.68821687",
"0.68765813",
"0.6853304",
"0.6852539",
"0.6852539",
"0.68471855",
"0.6817271",
"0.6817271",
"0.... | 0.65025926 | 41 |
Alternate initializer for compact input of coordinates | def from_floats(cls, *floats):
curves = []
for i in range(0, len(floats) - 2, 6):
p1 = (floats[i], floats[i + 1])
c1 = (floats[i + 2], floats[i + 3])
c2 = (floats[i + 4], floats[i + 5])
p2 = (floats[i + 6], floats[i + 7])
curves.append(CubicBezierCurve(p1, p2, c1, c2))
return cls(curves) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, lon: float = 0, lat: float = 0):\n super(Point2D, self).__init__(lon, lat)",
"def __init__(self, d):\n\t\tself._coords = [0] * d",
"def __init__(self, d):\n self._coords = [0]*d",
"def __init__(self, coordinates):\n\n if len(coordinates) != 5:\n raise ValueE... | [
"0.63444114",
"0.63369143",
"0.6208486",
"0.6187477",
"0.61472523",
"0.61472523",
"0.614598",
"0.6136781",
"0.61134976",
"0.6090093",
"0.607837",
"0.6063738",
"0.60410446",
"0.6038614",
"0.6038257",
"0.6028245",
"0.60152465",
"0.60152465",
"0.60152465",
"0.5991858",
"0.597739... | 0.0 | -1 |
Compares each curve with the next to verify continuity. Note that this function treats curves as directed, thus two curves that start at the same point will return `False` when compared. | def assert_continuous(*curves: CubicBezierCurve) -> bool:
if not curves:
raise ValueError("CurveChecker.assert_continuous() cannot be called on an empty list")
previous_curve = curves[0]
for curve in curves[1:]:
if previous_curve.p1 != curve.p0:
return False
previous_curve = curve
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_differentiable(*curves: CubicBezierCurve) -> bool:\n if not curves:\n raise ValueError(\"CurveChecker.assert_differentiable() cannot be called on an empty list\")\n\n if not assert_continuous(*curves):\n return False\n\n for curve0, curve1 in zip(curves, curves[1:]):\n if n... | [
"0.6867624",
"0.65761954",
"0.60859615",
"0.60859615",
"0.6069512",
"0.5920149",
"0.5899444",
"0.58113146",
"0.5743151",
"0.5739253",
"0.5737969",
"0.57277334",
"0.5719145",
"0.570918",
"0.5702754",
"0.5661689",
"0.5660275",
"0.5631335",
"0.5627203",
"0.5584733",
"0.55798703"... | 0.67138547 | 1 |
Verifies that the adjacent slopes between points are within specified tolerance of one another. Note that assert_collinear assumes ordered points; three actually collinear points passed with the middle point as the first or last argument will return `False` | def assert_collinear(*points: Point, tolerance: float = 1e-2) -> bool:
if len(points) < 3:
raise ValueError("CurveChecker.assert_collinear() must be called with at least three points")
thetas = [np.arctan2(p0[1] - p1[1], p0[0] - p1[0]) for p0, p1 in zip(points, points[1:])]
for t0, t1 in zip(thetas, thetas[1:]):
if abs(t0 - t1) > tolerance:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isCollinear(a,b,c):\r\n #return slope(a, b) == slope(b, c) == slope(c, a) #DOES NOT WORK\r\n #return (b[0] - a[0]) * (c[1] - a[1]) == (c[0] - a[0]) * (b[1] - a[1]) \r\n #return distance(a,b) + distance(b,c) == distance(a,c)\r\n x1 = a[0]\r\n y1 = a[1]\r\n x2 = b[0]\r\n y2 = b[1]\r\n x3 ... | [
"0.70717025",
"0.6318565",
"0.6101531",
"0.60696363",
"0.605181",
"0.59607244",
"0.5879398",
"0.5877427",
"0.5806856",
"0.57670236",
"0.5622218",
"0.5608094",
"0.5563991",
"0.55154955",
"0.5489862",
"0.54876494",
"0.54695606",
"0.5420858",
"0.5409832",
"0.5381098",
"0.5375114... | 0.80137265 | 0 |
Verifies differentiability of curves by checking collinearity of adjacent curves' control points | def assert_differentiable(*curves: CubicBezierCurve) -> bool:
if not curves:
raise ValueError("CurveChecker.assert_differentiable() cannot be called on an empty list")
if not assert_continuous(*curves):
return False
for curve0, curve1 in zip(curves, curves[1:]):
if not assert_collinear(curve0.c1, curve1.p0, curve1.c0):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isCollinear(a,b,c):\r\n #return slope(a, b) == slope(b, c) == slope(c, a) #DOES NOT WORK\r\n #return (b[0] - a[0]) * (c[1] - a[1]) == (c[0] - a[0]) * (b[1] - a[1]) \r\n #return distance(a,b) + distance(b,c) == distance(a,c)\r\n x1 = a[0]\r\n y1 = a[1]\r\n x2 = b[0]\r\n y2 = b[1]\r\n x3 ... | [
"0.6670978",
"0.6513759",
"0.6198429",
"0.6138979",
"0.61240935",
"0.61158717",
"0.60906714",
"0.6050059",
"0.6006302",
"0.59238374",
"0.5918185",
"0.59094197",
"0.58958864",
"0.5882234",
"0.5876733",
"0.5855049",
"0.579847",
"0.579847",
"0.577797",
"0.57669806",
"0.5764593",... | 0.68860763 | 0 |
Converts a path to a string representation for inclusion in an SVG file as | def path_to_string(path: Path) -> str:
assert_continuous(path)
pieces = ["M {} {}".format(path[0].p0[0], path[0].p0[1])]
for curve in iter(path): # iter cast not strictly necessary
piece = "C {} {} {} {} {} {}".format(
int(round(curve.c0[0])), int(round(curve.c0[1])),
int(round(curve.c1[0])), int(round(curve.c1[1])),
int(round(curve.p1[0])), int(round(curve.p1[1]))
)
pieces.append(piece)
return " ".join(pieces) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_string(path: pathlib.Path) -> str:\n return path.as_posix()",
"def path_to_str(path):\n if hasattr(path, '__fspath__'):\n path = as_str_any(path.__fspath__())\n return path",
"def save_svg(string, file_name):\n file_handle = file(file_name, \"w\")\n file_handle.write(string)\n ... | [
"0.664361",
"0.6505727",
"0.6453225",
"0.6349524",
"0.631118",
"0.62037516",
"0.6048819",
"0.6006023",
"0.5888196",
"0.5883319",
"0.5875403",
"0.5838811",
"0.578169",
"0.57720757",
"0.57636064",
"0.5753614",
"0.5715025",
"0.57089794",
"0.569792",
"0.5695481",
"0.56592214",
... | 0.6743669 | 0 |
Tests that the processor can be initialized. | def setUp(self):
self.logger = mock.MagicMock()
test_state = state.DFTimewolfState(config.Config)
self.turbinia_processor = turbinia_base.TurbiniaProcessorBase(
test_state, self.logger)
file_path = os.path.join(
CURRENT_DIR, "test_data", "turbinia_request_status.json")
self._request_status = json.load(open(file_path)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _should_initialize_check_run(self, payload):\n action = payload.get('action')\n return action in self.initialize_actions or self.initialize_actions is None",
"def test_init_success(self):\n found = False\n try:\n pyint = Interpreter()\n except InitializationExcep... | [
"0.6729422",
"0.65866035",
"0.6567162",
"0.65516055",
"0.63776916",
"0.63715816",
"0.63663733",
"0.626371",
"0.624758",
"0.62021387",
"0.6187901",
"0.6163606",
"0.6123539",
"0.61059314",
"0.60137165",
"0.5975385",
"0.5962163",
"0.59609634",
"0.5944189",
"0.5939157",
"0.593644... | 0.0 | -1 |
Tests the TurbiniaSetup method. | def testTurbiniaSetup(self, _mock_read_config):
_mock_read_config.return_value = {"OUTPUT_DIR": "/tmp"}
self.turbinia_processor.TurbiniaSetUp(
project="turbinia-project",
turbinia_auth=False,
turbinia_recipe=None,
turbinia_zone="us-central1f",
turbinia_api="http://localhost:8001",
incident_id="123456789",
sketch_id="12345",
)
self.assertEqual(self.turbinia_processor.project, "turbinia-project")
self.assertEqual(self.turbinia_processor.turbinia_zone, "us-central1f")
self.assertEqual(
self.turbinia_processor.turbinia_api, "http://localhost:8001")
self.assertEqual(self.turbinia_processor.incident_id, "123456789")
self.assertEqual(self.turbinia_processor.sketch_id, "12345")
self.assertEqual(self.turbinia_processor.output_path, "/tmp")
self.assertEqual(self.turbinia_processor.turbinia_recipe, None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup():\n pass",
"def TurbiniaSetUp(\n self, project: str, turbinia_auth: bool,\n turbinia_recipe: Union[str, None], turbinia_zone: str, turbinia_api: str,\n incident_id: str, sketch_id: int) -> None:\n self.project = project\n self.turbinia_auth = turbinia_auth\n self.turbinia_ap... | [
"0.6720269",
"0.65703833",
"0.6467602",
"0.6449046",
"0.6447386",
"0.64372605",
"0.64077723",
"0.6403362",
"0.63865745",
"0.635866",
"0.6345223",
"0.63323843",
"0.63103575",
"0.6282889",
"0.6277148",
"0.62679124",
"0.62679124",
"0.62679124",
"0.62679124",
"0.62679124",
"0.626... | 0.77893466 | 0 |
Tests the TurbiniaStart method. | def testTurbiniaStart(self, mock_create_request):
mock_create_request.return_value = {
"request_id": "41483253079448e59685d88f37ab91f7"
}
mock_api_instance = mock.MagicMock()
mock_api_instance.create_request = mock_create_request
self.turbinia_processor.requests_api_instance = mock_api_instance
evidence = {
"type": "GoogleCloudDisk",
"disk_name": "disk-1",
"project": "project-1",
"zone": "us-central1-f",
}
request_id = self.turbinia_processor.TurbiniaStart(
evidence=evidence, yara_rules=YARA_RULE)
self.assertEqual(request_id, "41483253079448e59685d88f37ab91f7") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testStart(self):\n self.machine.stop()\n self.machine.start(safe.Settling)\n \n self.assertCurrentMotion(motion.common.Hover)\n \n self.releaseTimer(safe.Settling.SETTLED)\n self.assertCurrentState(safe.Grabbing)",
"def startTestRun(self):",
"def startTest(a... | [
"0.71255654",
"0.6825471",
"0.6790718",
"0.66931415",
"0.6602822",
"0.6602822",
"0.6602822",
"0.6602822",
"0.6589439",
"0.6544202",
"0.65038764",
"0.650213",
"0.63993055",
"0.63993055",
"0.6367139",
"0.6244631",
"0.6237109",
"0.6224533",
"0.61932135",
"0.61699873",
"0.6169987... | 0.63942826 | 14 |
Tests the TurbiniaWait method. | def testTurbiniaWait(self, mock_get_request_status, _):
mock_api_instance = mock.MagicMock()
mock_api_instance.create_request = mock_get_request_status
self.turbinia_processor.requests_api_instance = mock_api_instance
mock_get_request_status.return_value = self._request_status
for task, path in self.turbinia_processor.TurbiniaWait(TASK_ID):
# Check that the task and path are correct for a PlasoParserTask
if task["id"] == TASK_ID:
self.assertEqual(task, self._request_status["tasks"][0])
self.assertEqual(path, TEST_TASK_PATH)
break | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait():\n pass",
"def wait():\n time.sleep(1)",
"def do_wait(self):\n pass",
"def wait(wait_time=WAIT_TIME):\n # time.sleep(wait_time)\n pass",
"def wait(self):\n pass",
"def wait(self):\n pass",
"def wait(self):\n time.sleep(0.010)",
"def wait(cls, quad):\n\t\... | [
"0.761487",
"0.74810785",
"0.7287967",
"0.6939687",
"0.68942183",
"0.68942183",
"0.6890984",
"0.6889294",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6812686",
"0.6796886",
"0.6759803",
"0.67246556",
... | 0.6903799 | 4 |
Tests the _isInterestingPath method. | def testIsInterestingPath(self):
# pylint: disable=protected-access
self.assertTrue(self.turbinia_processor._isInterestingPath(TEST_TASK_PATH)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _isInterestingPath(self, path: str) -> bool:\n for suffix in self.extensions:\n if path.endswith(suffix):\n return True\n return False",
"def test_find_path_bi():\n assert True",
"def is_path(self, s):\n return True",
"def _is_interesting_op(self, op):\n return op_priority(... | [
"0.72631514",
"0.58760685",
"0.58147526",
"0.56765735",
"0.55693245",
"0.55457276",
"0.54889286",
"0.5446209",
"0.53737456",
"0.53603786",
"0.53477657",
"0.5298553",
"0.5297065",
"0.5293575",
"0.5228027",
"0.5226015",
"0.519997",
"0.51928556",
"0.5165649",
"0.51393193",
"0.51... | 0.81139785 | 0 |
Tests the _ExtractFiles method. | def testExtractPath(self, mock_tempdir):
mock_tempdir.return_value = '/tmp'
file_path = os.path.join(
CURRENT_DIR, "test_data", "c4e9abd577db475484b2ded34a011b96.tgz")
expected_local_path = f"/tmp{TEST_TASK_PATH}"
# pylint: disable=protected-access
local_path = self.turbinia_processor._ExtractFiles(
file_path, TEST_TASK_PATH)
self.assertEqual(local_path, expected_local_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_files(self) -> list:\n pass",
"def extract(self):\n self.build_path_pairs()\n self.extract_field_blocks()\n self.assert_filenames()",
"def test_zip_files(self):\n base_zip_files = ['whypython.txt', 'states.dbf', 'cities.kmz']\n\n text_file = os.path.join(os... | [
"0.6961958",
"0.67344284",
"0.65078896",
"0.64383835",
"0.6424595",
"0.6330281",
"0.6321087",
"0.63068205",
"0.62984717",
"0.62395144",
"0.62120587",
"0.61898607",
"0.6165155",
"0.61557406",
"0.6154367",
"0.6150874",
"0.6107343",
"0.61028737",
"0.60906625",
"0.60642004",
"0.6... | 0.64720875 | 3 |
Tests the RefreshClientCredentials method. | def testRefreshClientCredentials(self,
mock_get_credentials, mock_initialize_client):
# Set an expired token.
self.turbinia_processor.credentials = mock.MagicMock(
expiry = FAKE_CREDENTIALS['expiry'], expired = True)
self.turbinia_processor.RefreshClientCredentials()
mock_get_credentials.assert_called_once()
mock_initialize_client.assert_called_once() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RefreshClientCredentials(self) -> bool:\n refresh = False\n if self.credentials and self.credentials.expired:\n self.credentials = self.GetCredentials(\n self.credentials_path, self.client_secrets_path)\n self.client = self.InitializeTurbiniaApiClient(self.credentials)\n refresh =... | [
"0.7480343",
"0.6987335",
"0.6519567",
"0.647827",
"0.64674634",
"0.6362675",
"0.6351274",
"0.6320688",
"0.6314245",
"0.6286668",
"0.6279366",
"0.6243212",
"0.6241278",
"0.6184748",
"0.6173102",
"0.61290675",
"0.6063998",
"0.6048179",
"0.60427195",
"0.6041711",
"0.6039306",
... | 0.791131 | 0 |
Tests the InitializeTurbiniaApiClient method. | def testInitializeTurbiniaApiClientNoCreds(self, mock_get_credentials):
self.turbinia_processor.turbinia_api = 'http://127.0.0.1:8000'
self.turbinia_processor.turbinia_auth = True
mock_credentials = mock.MagicMock(spec=Credentials, id_token = FAKE_CREDENTIALS['token'])
mock_credentials.id_token = mock.MagicMock()
mock_credentials.id_token.return_value = FAKE_CREDENTIALS['token']
self.turbinia_processor.credentials = mock_credentials
mock_get_credentials.return_value = mock_credentials
result = self.turbinia_processor.InitializeTurbiniaApiClient(None)
mock_get_credentials.assert_called_once()
self.assertIsInstance(result, turbinia_api_lib.ApiClient) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testInitializeTurbiniaApiClient(self, mock_get_credentials):\n self.turbinia_processor.turbinia_api = 'http://127.0.0.1:8000'\n self.turbinia_processor.turbinia_auth = True\n mock_credentials = mock.MagicMock(spec=Credentials, id_token = FAKE_CREDENTIALS['token'])\n mock_credentials.id_token = mock... | [
"0.763972",
"0.71817064",
"0.69348216",
"0.6902786",
"0.6898086",
"0.68290806",
"0.68290806",
"0.6813784",
"0.6806354",
"0.67816716",
"0.6775598",
"0.6775598",
"0.6775598",
"0.6712668",
"0.6631375",
"0.65852684",
"0.65815634",
"0.6529811",
"0.6472687",
"0.6472687",
"0.6472687... | 0.73480415 | 1 |
Tests the InitializeTurbiniaApiClient method. | def testInitializeTurbiniaApiClient(self, mock_get_credentials):
self.turbinia_processor.turbinia_api = 'http://127.0.0.1:8000'
self.turbinia_processor.turbinia_auth = True
mock_credentials = mock.MagicMock(spec=Credentials, id_token = FAKE_CREDENTIALS['token'])
mock_credentials.id_token = mock.MagicMock()
mock_credentials.id_token.return_value = FAKE_CREDENTIALS['token']
self.turbinia_processor.credentials = mock_credentials
mock_get_credentials.return_value = mock_credentials
result = self.turbinia_processor.InitializeTurbiniaApiClient(mock_credentials)
mock_get_credentials.assert_not_called()
self.assertIsInstance(result, turbinia_api_lib.ApiClient) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testInitializeTurbiniaApiClientNoCreds(self, mock_get_credentials):\n self.turbinia_processor.turbinia_api = 'http://127.0.0.1:8000'\n self.turbinia_processor.turbinia_auth = True\n mock_credentials = mock.MagicMock(spec=Credentials, id_token = FAKE_CREDENTIALS['token'])\n mock_credentials.id_token... | [
"0.73480415",
"0.71817064",
"0.69348216",
"0.6902786",
"0.6898086",
"0.68290806",
"0.68290806",
"0.6813784",
"0.6806354",
"0.67816716",
"0.6775598",
"0.6775598",
"0.6775598",
"0.6712668",
"0.6631375",
"0.65852684",
"0.65815634",
"0.6529811",
"0.6472687",
"0.6472687",
"0.64726... | 0.763972 | 0 |
Test whether a section exists. | def has_section(self, section):
return self.cfg.has_section(section) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_section_exist(self, section_name: str) -> bool:\n pass",
"def has_section(self, section):\n raise NotImplementedError()",
"def has_section(self, section):\n if section in self._dict:\n return True\n return False",
"def has_section(self, section):\n\n return se... | [
"0.8818048",
"0.8469707",
"0.8389857",
"0.8208384",
"0.8178421",
"0.8061962",
"0.7974788",
"0.7825325",
"0.752125",
"0.7518481",
"0.7350608",
"0.7341947",
"0.7030508",
"0.6875858",
"0.6844375",
"0.6687593",
"0.6592266",
"0.6513766",
"0.64952224",
"0.645685",
"0.6444705",
"0... | 0.82564044 | 3 |
Test whether an option exists. | def has_option(self, option, section = None):
if section is None:
section = self.default_section
return self.cfg.has_option(section, option) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_option(self, key):\n\n return key in self.__opt",
"def has_option(self, name):\n return self.option_settings[name]",
"def has_option(self, option):\n\t\treturn self.config_parser.has_option(self.section_name, option)",
"def has_option(self, option):\n splitvals = option.split('/'... | [
"0.8260075",
"0.81346714",
"0.79610306",
"0.7878082",
"0.78457946",
"0.7843575",
"0.78201646",
"0.78074056",
"0.77991354",
"0.7590212",
"0.75709635",
"0.7506453",
"0.74686354",
"0.73545367",
"0.73482585",
"0.72637665",
"0.723397",
"0.69554585",
"0.68729013",
"0.6776543",
"0.6... | 0.7794908 | 9 |
Parse OpenSSLstyle foo.0, foo.1, ... subscripted options. Returns a list of values matching the specified option name. | def multiget(self, option, section = None):
matches = []
if section is None:
section = self.default_section
if self.cfg.has_option(section, option):
matches.append((-1, self.get(option, section = section)))
for key, value in self.cfg.items(section):
s = key.rsplit(".", 1)
if len(s) == 2 and s[0] == option and s[1].isdigit():
matches.append((int(s[1]), self.get(option, section = section)))
matches.sort()
return [match[1] for match in matches] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_option(self, name):\r\n if not isinstance(name, str):\r\n name = \" \".join(name)\r\n lines = self.sendAndRecv(\"GETCONF %s\\r\\n\" % name)\r\n\r\n r = []\r\n for _,line,_ in lines:\r\n try:\r\n key, val = line.split(\"=\", 1)\r\n r.append((key,val))\r\n except Valu... | [
"0.5681802",
"0.5620391",
"0.5565046",
"0.541359",
"0.53751975",
"0.5340231",
"0.5283279",
"0.5276728",
"0.52554685",
"0.5251639",
"0.51984483",
"0.5196909",
"0.519201",
"0.5174309",
"0.5122386",
"0.51024044",
"0.51020473",
"0.5095427",
"0.5034037",
"0.5030856",
"0.50224656",... | 0.5834238 | 0 |
Replacement function for indirect variable substitution. This is intended for use with re.subn(). | def _repl(self, m):
section, option = m.group(1, 2)
if section == "ENV":
return os.getenv(option, "")
else:
return self.cfg.get(section, option) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_variable_substitution(item):\n if isinstance(item, str):\n try:\n item = re_keyref.sub(getdata, item)\n except KeyError, err:\n print >> sys.stderr, (\n \"Use of undefined key in variable substitution: %s\"\n % ... | [
"0.6543323",
"0.64928055",
"0.64095277",
"0.640149",
"0.6348403",
"0.6247242",
"0.61828613",
"0.6170363",
"0.60472184",
"0.6013036",
"0.6008018",
"0.59389454",
"0.5931353",
"0.58995754",
"0.5893741",
"0.58664304",
"0.58525014",
"0.58441067",
"0.5818302",
"0.5775025",
"0.57669... | 0.0 | -1 |
Get an option, perhaps with a default value. | def get(self, option, default = None, section = None):
if section is None:
section = self.default_section
if default is not None and not self.cfg.has_option(section, option):
return default
val = self.cfg.get(section, option)
while True:
val, modified = self._regexp.subn(self._repl, val, 1)
if not modified:
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_option(self, name, datatype, default):\n return config.get_option(self._options,\n name,\n type=datatype,\n default=default)",
"def __get_option(self, option):\n if option in Config.OPTIONS.keys... | [
"0.8309457",
"0.8285595",
"0.8050056",
"0.78617734",
"0.78480136",
"0.7729407",
"0.76687425",
"0.7613236",
"0.76116955",
"0.7508143",
"0.7377448",
"0.7367811",
"0.7332215",
"0.7305065",
"0.7281587",
"0.7236693",
"0.72000957",
"0.7122571",
"0.71041566",
"0.7097126",
"0.7038417... | 0.6900306 | 25 |
Get a boolean option, perhaps with a default value. | def getboolean(self, option, default = None, section = None):
v = self.get(option, default, section)
if isinstance(v, str):
v = v.lower()
if v not in self.cfg._boolean_states:
raise ValueError, "Not a boolean: %s" % v
v = self.cfg._boolean_states[v]
return v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getboolean(self, option, default=None):\n\t\treturn self._get_raw(option, 'boolean', default)",
"def get_bool(options, name, default=False):\n value = options.get(name)\n if not value:\n return default\n if value.lower() == 'true':\n return True\n elif value.lower() == 'false':\n ... | [
"0.8732398",
"0.86066973",
"0.84299433",
"0.8366191",
"0.82892025",
"0.8260845",
"0.822819",
"0.8115869",
"0.78542686",
"0.7821285",
"0.78019625",
"0.7718613",
"0.7465177",
"0.7321887",
"0.73198515",
"0.7313598",
"0.7216047",
"0.7181007",
"0.7140331",
"0.71299386",
"0.7106636... | 0.8165139 | 7 |
Get an integer option, perhaps with a default value. | def getint(self, option, default = None, section = None):
return int(self.get(option, default, section)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getint(self, option, default=None):\n\t\treturn self._get_raw(option, 'int', default)",
"def getint(self, option):\n return getint(self.name, option)",
"def getint(self, section, option, default=None):\r\n return self.get(section, option, type=int, default=default)",
"def getint(self, option, a... | [
"0.84793097",
"0.81527907",
"0.79768705",
"0.7929183",
"0.7760084",
"0.7490237",
"0.73363376",
"0.71646047",
"0.7082002",
"0.7010749",
"0.6840518",
"0.66669184",
"0.65775895",
"0.6542784",
"0.65416443",
"0.652801",
"0.63949615",
"0.6394363",
"0.63876903",
"0.633896",
"0.63153... | 0.8415297 | 1 |
Get a long integer option, perhaps with a default value. | def getlong(self, option, default = None, section = None):
return long(self.get(option, default, section)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getint(self, option, default = None, section = None):\n return int(self.get(option, default, section))",
"def getLong(self, int: int, int2: int) -> int:\n ...",
"def getLong(t, swipl):\n i = c_long()\n if swipl.PL_get_long(t, byref(i)):\n return i.value\n else:\n raise Inva... | [
"0.70192164",
"0.68363434",
"0.6702272",
"0.66861874",
"0.6630546",
"0.66111416",
"0.6431476",
"0.6385897",
"0.6310543",
"0.628531",
"0.6267423",
"0.62353796",
"0.6210837",
"0.61966425",
"0.6178884",
"0.6079542",
"0.60778195",
"0.60364276",
"0.59944767",
"0.59922874",
"0.5992... | 0.8568428 | 0 |
Consolidated control for all the little global control flags scattered through the libraries. This isn't a particularly good place for this function to live, but it has to live somewhere and making it a method of the config parser from which it gets all of its data is less silly than the available alternatives. | def set_global_flags(self):
import rpki.http, rpki.x509, rpki.sql, rpki.async, rpki.log
try:
rpki.http.debug_http = self.getboolean("debug_http")
except ConfigParser.NoOptionError:
pass
try:
rpki.http.want_persistent_client = self.getboolean("want_persistent_client")
except ConfigParser.NoOptionError:
pass
try:
rpki.http.want_persistent_server = self.getboolean("want_persistent_server")
except ConfigParser.NoOptionError:
pass
try:
rpki.http.use_adns = self.getboolean("use_adns")
except ConfigParser.NoOptionError:
pass
try:
rpki.http.enable_ipv6_clients = self.getboolean("enable_ipv6_clients")
except ConfigParser.NoOptionError:
pass
try:
rpki.http.enable_ipv6_servers = self.getboolean("enable_ipv6_servers")
except ConfigParser.NoOptionError:
pass
try:
rpki.x509.CMS_object.debug_cms_certs = self.getboolean("debug_cms_certs")
except ConfigParser.NoOptionError:
pass
try:
rpki.sql.sql_persistent.sql_debug = self.getboolean("sql_debug")
except ConfigParser.NoOptionError:
pass
try:
rpki.async.timer.gc_debug = self.getboolean("gc_debug")
except ConfigParser.NoOptionError:
pass
try:
rpki.async.timer.run_debug = self.getboolean("timer_debug")
except ConfigParser.NoOptionError:
pass
try:
rpki.x509.XML_CMS_object.dump_outbound_cms = rpki.x509.DeadDrop(self.get("dump_outbound_cms"))
except ConfigParser.NoOptionError:
pass
try:
rpki.x509.XML_CMS_object.dump_inbound_cms = rpki.x509.DeadDrop(self.get("dump_inbound_cms"))
except ConfigParser.NoOptionError:
pass
try:
rpki.async.gc_summary(self.getint("gc_summary"), self.getint("gc_summary_threshold", 0))
except ConfigParser.NoOptionError:
pass
try:
rpki.log.enable_tracebacks = self.getboolean("enable_tracebacks")
except ConfigParser.NoOptionError:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _GclStyleSettings(self):\n settings = {\n 'port': self.GetCodeReviewSetting('TRYSERVER_HTTP_PORT'),\n 'host': self.GetCodeReviewSetting('TRYSERVER_HTTP_HOST'),\n 'svn_repo': self.GetCodeReviewSetting('TRYSERVER_SVN_URL'),\n 'gerrit_url': self.GetCodeReviewSetting('TRYSERVER_GERRIT_URL'),... | [
"0.5948904",
"0.55440557",
"0.55275595",
"0.5320084",
"0.5296819",
"0.5249181",
"0.5204246",
"0.520022",
"0.51432735",
"0.5137308",
"0.5134827",
"0.5134588",
"0.5134572",
"0.5123408",
"0.50960565",
"0.5094958",
"0.50912803",
"0.50796866",
"0.50630355",
"0.50593835",
"0.505469... | 0.66763616 | 0 |
Read inputs and find keys with multiple values. | def main() :
parser = argparse.ArgumentParser()
parser.add_argument("key",
help="column name of the KEY",
nargs=1)
parser.add_argument("val",
help="column name of the VALUE",
nargs=1)
parser.add_argument("infile",
help="CSV input file",
nargs=1)
parser.add_argument("outfile",
help="CSV output file",
nargs=1)
try :
args = parser.parse_args()
except IOError as e :
print (e)
sys.exit(1)
analyzer = Analyzer(args.key[0], args.val[0])
analyzer.read(*args.infile)
analyzer.write(*args.outfile) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keysWhichMatch(cls, *args):\n if len(cls.keys) < len(args) > 0:\n raise ValueError('Number of keys provided is too long.\\n'\n 'Len Class Keys: %s\\n'\n 'Len Provided Keys: %s\\n' % (len(cls.keys), len(args)))\n\n index = 0\n ... | [
"0.5824653",
"0.5802758",
"0.578554",
"0.5753453",
"0.5746162",
"0.5673391",
"0.5568094",
"0.5562528",
"0.5508408",
"0.5508204",
"0.55056906",
"0.5499257",
"0.5487545",
"0.54547495",
"0.5448356",
"0.5445263",
"0.54099",
"0.5394247",
"0.5388735",
"0.53838193",
"0.53304183",
... | 0.0 | -1 |
Checks for number of vertices >>> num_vertices([[1, 1], [1, 1]], [[1, 1, 1], [1, 1, 1], [1, 1, 1]]) False >>> num_vertices([[1, 0], [0, 1]], [[0, 0], [0, 0]]) True | def num_vertices(graph1: list, graph2: list):
if len(graph1[0]) != len(graph2[0]):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hasvertices(self):\n if len(self.vertices) > 0:\n return True\n else:\n return False",
"def num_vertices(self):\n return len(self.vertices)",
"def num_vertices(self):\n return len(self.vertices)",
"def getNumVertices(self):\n return len(self.V)",
... | [
"0.7340938",
"0.7330129",
"0.7330129",
"0.71462345",
"0.7098103",
"0.70285016",
"0.6986101",
"0.6935374",
"0.68259686",
"0.67648",
"0.67457217",
"0.66626644",
"0.6626465",
"0.6615794",
"0.6540091",
"0.6527618",
"0.6514949",
"0.64980805",
"0.64802784",
"0.64247876",
"0.6411660... | 0.7056209 | 5 |
Checks for number of edges >>> num_edges([[1, 1], [0, 1]], [[1, 1], [1, 1]]) False >>> num_edges([[1, 0], [0, 1]], [[0, 1], [1, 0]]) True | def num_edges(graph1: list, graph2: list):
check1 = 0
check2 = 0
for row, _ in enumerate(graph1):
for column, _ in enumerate(graph1[row]):
if graph1[row][column] == 1:
check1 += 1
if graph2[row][column] == 1:
check2 += 1
return check1 == check2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_edges(self):\r\n return len(self.__generate_edges())",
"def _number_of_edges(self):\n if self._edges is None:\n return 0\n return len(self._edges)",
"def Test_NumEdges(Graph_MD):\n N_Edges = float(Graph_MD.number_of_edges())\n\n return N_Edges",
"def has_edges(s... | [
"0.7388578",
"0.73457235",
"0.7252701",
"0.712351",
"0.70799005",
"0.7057893",
"0.6985507",
"0.6887687",
"0.68730575",
"0.68627745",
"0.68099093",
"0.6797033",
"0.66984785",
"0.6688148",
"0.66881293",
"0.66494614",
"0.6648401",
"0.6627459",
"0.66019803",
"0.6598041",
"0.65855... | 0.68215644 | 10 |
Checks for vertices' degrees >>> vertices_degree([[1, 0], [1, 1]], [[0, 1], [1, 0]]) (False, []) >>> vertices_degree([[1, 1], [0, 1]], [[1, 0], [1, 1]]) (True, [2, 1], [1, 2]) | def vertices_degree(graph1: list, graph2: list):
check1 = []
check2 = []
for row, _ in enumerate(graph1):
degree1 = 0
degree2 = 0
for column, _ in enumerate(graph1[row]):
if graph1[row][column] == 1:
degree1 += 1
if graph2[row][column] == 1:
degree2 += 1
check1.append(degree1)
check2.append(degree2)
if sorted(check1) == sorted(check2):
return True, check1, check2
return False, [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _has_degree(\n self,\n degree: int,\n vertex: Vertex,\n ) -> bool:\n\n return vertex.get_id() in self._vertices_of_degree[degree]",
"def vertice_degree(self):\r\n if(self.is_empty()):\r\n raise ValueError(\"Graph is empty.\")\r\n else:\r\n if... | [
"0.70981395",
"0.6648923",
"0.66187066",
"0.6453982",
"0.6208992",
"0.6075277",
"0.6049173",
"0.6037286",
"0.59577584",
"0.5948439",
"0.59199977",
"0.5896408",
"0.58028036",
"0.580261",
"0.57468504",
"0.57298976",
"0.5702665",
"0.5702665",
"0.56859505",
"0.56500363",
"0.56339... | 0.6969743 | 1 |
Checks if there can be bijection between two graphs | def permutations(graph1: list, graph2: list, degrees: tuple):
degrees1 = degrees[0]
degrees2 = degrees[1]
check1 = []
check2 = []
for index, _ in enumerate(degrees1):
degree = degrees1[index]
temp = []
for vertex, _ in enumerate(graph1[index]):
if graph1[index][vertex] == 1:
temp.append(degrees1[vertex])
check1.append((degree, tuple(sorted(temp))))
for index, _ in enumerate(degrees2):
degree = degrees2[index]
temp = []
for vertex in range(len(graph2[index])):
if graph2[index][vertex] == 1:
temp.append(degrees2[vertex])
check2.append((degree, tuple(sorted(temp))))
return len(set(check1 + check2)) == len(set(check1)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_bipartite(G):\n try:\n bipartite_color(G)\n return True\n except:\n return False",
"def compare_graphs(self):\n\t\tpass",
"def graph_issuperset(graph1, graph2):\n\n # Validate if all arguments are Graphs\n check_graphbase_instance(graph1, graph2)\n\n return graph1.nod... | [
"0.58745533",
"0.58431983",
"0.5821069",
"0.58176845",
"0.5800676",
"0.5800201",
"0.571649",
"0.56977814",
"0.56428045",
"0.56401634",
"0.5639373",
"0.5630606",
"0.5611228",
"0.5610141",
"0.5608601",
"0.559945",
"0.55920273",
"0.5584586",
"0.557866",
"0.5549889",
"0.55390096"... | 0.5283513 | 41 |
Main function for checking isomorphism >>> check_for_isomorphism([(1, 2), (1, 3), (1, 5),\ (2, 4), (2, 6), (3, 1), (3, 4),\ (4, 2), (5, 1), (5, 6), (5, 7), (6, 8), (7, 8)],\ [(1, 2), (1, 3), (1, 5), (2, 4), (3, 1), (3, 4),\ (3, 7), (4, 2), (5, 6), (5, 7), (6, 8), (7, 8)]) True >>> check_for_isomorphism([(1, 3), (1, 5),\ (2, 4), (2, 6), (3, 1), (3, 4),\ (4, 2), (5, 1), (5, 6), (5, 7), (6, 8), (7, 8)],\ [(1, 2), (1, 3), (1, 5), (2, 4), (3, 1), (3, 4),\ (3, 7), (4, 2), (5, 6), (5, 7), (6, 8), (7, 8)]) False | def check_for_isomorphism(graph1: list, graph2: list, directed=False) -> bool:
matrix1 = get_adjancy_matrix(graph1, directed)
matrix2 = get_adjancy_matrix(graph2, directed)
if num_vertices(matrix1, matrix2):
if num_edges(matrix1, matrix2):
degrees = vertices_degree(matrix1, matrix2)
if degrees[0]:
return permutations(matrix1, matrix2, degrees[1:])
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_check_isomorphism(self):\n mol1 = Molecule(smiles='[O-][N+]#N')\n mol2 = Molecule(smiles='[N-]=[N+]=O')\n self.assertTrue(converter.check_isomorphism(mol1, mol2))",
"def test_is_isomorphic(self):\n mol1 = converter.s_bonds_mol_from_xyz(self.xyz1['dict'])\n mol2 = conve... | [
"0.68144727",
"0.61583287",
"0.57273215",
"0.5682086",
"0.561438",
"0.5609958",
"0.5602563",
"0.55251133",
"0.5451978",
"0.5407561",
"0.5355188",
"0.5268322",
"0.5252409",
"0.5186853",
"0.51790214",
"0.50514466",
"0.50385714",
"0.49780542",
"0.49707803",
"0.4955957",
"0.49171... | 0.5521835 | 8 |
r""" Wait for the user to type a character (and hit Enter). If the user enters one of the characters in letters, return that character. If the user hits Enter without entering a character, and default is specified, returns `default`, Otherwise, asks the user to enter a character again. | def _prompt(letters='yn', default=None):
import sys
while True:
try:
inputstr = sys.stdin.readline().strip()
except KeyboardInterrupt:
sys.exit(0)
if inputstr and inputstr in letters:
return inputstr
if default is not None and inputstr == '':
return default
print 'Come again?' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prompt(letters='yn', default=None):\n while True:\n try:\n input_text = sys.stdin.readline().strip()\n except KeyboardInterrupt:\n sys.exit(0)\n if input_text and input_text in letters:\n return input_text\n if default is not None and input_text ... | [
"0.7521456",
"0.7162696",
"0.7019684",
"0.6967578",
"0.6841188",
"0.67817444",
"0.6743779",
"0.66840625",
"0.66546315",
"0.65572464",
"0.6538709",
"0.64224786",
"0.636659",
"0.63616836",
"0.63427144",
"0.63147855",
"0.6242766",
"0.61260843",
"0.60846496",
"0.6079177",
"0.6052... | 0.750709 | 1 |
Function to remove test results and confirmations older than 10 blocks | async def cleanTestResults(CURRENT_HEIGHT):
LAST_GOOD_HEIGHT = int(CURRENT_HEIGHT) - 10
for testId in list(testResults):
if int(testId) <= LAST_GOOD_HEIGHT:
del testResults[testId]
for testId in list(testConfirmations):
if int(testId) <= LAST_GOOD_HEIGHT:
del testConfirmations[testId] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remaining_batch_tests(loaded_batch_tests):\n remaining_tests = batch_test_set - set(loaded_batch_tests)\n with open('remaining_tests.txt', mode='w') as outfile:\n for batch_test in remaining_tests:\n outfile.write(\"%s\\n\" % batch_test)",
"def clean_leftovers(tests):\n for test in... | [
"0.6036735",
"0.58126444",
"0.5707902",
"0.5680992",
"0.5655867",
"0.56548756",
"0.5543772",
"0.5505886",
"0.5502805",
"0.5481863",
"0.54809284",
"0.5464488",
"0.5420158",
"0.5416538",
"0.5402889",
"0.5371889",
"0.5359482",
"0.5342731",
"0.53407174",
"0.5334368",
"0.5320321",... | 0.73820996 | 0 |
POST handler that accepts uploads of files. It does not store the content of the file, just creates entry in the dictionary to keep track of upload activity. | async def UploadHandlerMem(request):
# You cannot rely on Content-Length if transfer is chunked.
try:
fileSize = 0
timestampStart = datetime.utcnow()
usedHandler = 'UploadHandlerMem'
try:
testId = request.match_info['testId']
except Exception as e:
testId = "noId"
try:
sourceHostPort = request.match_info['sourceHostPort']
except Exception as e:
sourceHostPort = "noPort"
try:
fileName = request.match_info['fileName']
except Exception as e:
fileName = "noFileName"
while True:
chunk, is_end_of_http_chunk = await request.content.readchunk()
if not chunk:
break
fileSize += len(chunk)
peername = request.transport.get_extra_info('peername')
if peername is not None:
host, port = peername
else:
host = 'nohost'
timestampEnd = datetime.utcnow()
taskDuration = str(timestampEnd - timestampStart)
if testId != "noId" and sourceHostPort != "noPort" and fileName != "noFileName":
testConfirmations.setdefault(testId, {}).setdefault(NODE_ADDRESS[0]+':'+str(HOST_PORT), {}).setdefault(host+':'+sourceHostPort, {})['UploadHandlerMem'] = { 'status': 'success', 'message': 'File uploaded', 'testId': testId, 'usedHandler': 'UploadHandlerMem', 'taskDuration': taskDuration, 'fileName': fileName, 'sourceFileName': '10k.txt', 'fileSize': fileSize, 'timestampStart': str(timestampStart), 'timestampEnd': str(timestampEnd) }
response_obj = { 'status': 'success', 'message': 'File uploaded to memory', 'testId': testId, 'usedHandler': usedHandler, 'taskDuration': taskDuration, 'fileName': fileName, 'fileSize': fileSize, 'timestampStart': str(timestampStart), 'timestampEnd': str(timestampEnd) }
return web.json_response(response_obj)
except Exception as e:
response_obj = { 'status' : 'failed', 'reason': str(e) }
print(str(e))
return web.json_response(response_obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n filename = str(time.time())\n filepath = os.path.join(\n os.path.join(current_app.config['UPLOAD_FOLDER'], filename))\n with open(filepath, 'bw') as uploadfile:\n chunk_size = 1024\n while True:\n chunk = request.stream.read(chu... | [
"0.7198825",
"0.7094963",
"0.69860333",
"0.69567823",
"0.6920896",
"0.6851648",
"0.68024033",
"0.6728201",
"0.6680211",
"0.65697706",
"0.6507112",
"0.6479238",
"0.6470818",
"0.64561504",
"0.64233595",
"0.64167655",
"0.6380935",
"0.63550353",
"0.62920946",
"0.62501407",
"0.623... | 0.0 | -1 |
POST handler that uploads file to remote host. | async def UploadToRemoteNodeHandler(request):
fileSize = 0
timestampStart = datetime.utcnow()
usedHandler = 'uploadFileToRemoteNode'
try:
data = await request.post()
try:
testId = data['testId']
except Exception as e:
testId = str(uuid.uuid4())
try:
fileName = data['fileName']
except Exception as e:
fileName = '1k.txt'
try:
destinationFileName = data['destinationFileName']
except Exception as e:
destinationFileName = fileName
try:
destinationHost = data['destinationHost']
except Exception as e:
print('no destinationHost')
fileUrl = 'http://'+destinationHost+'/uploadFile/'+testId
#print(fileUrl)
async with ClientSession() as session:
try:
async with ClientSession() as session:
async with session.post(fileUrl, data ={
'testId': testId,
'fileName': destinationFileName,
'file': download_files[fileName]
}) as response:
data = await response.json()
fileSize = len(download_files[fileName])
timestampEnd = datetime.utcnow()
taskDuration = str(timestampEnd - timestampStart)
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["fileName"] = fileName
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["destinationFileName"] = destinationFileName
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["fileSize"] = fileSize
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["timestampStart"] = str(timestampStart)
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["timestampEnd"] = str(timestampEnd)
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["taskDuration"] = taskDuration
response_obj = { 'status': 'success', 'message': 'File uploaded', 'testId': testId, 'usedHandler': usedHandler, 'taskDuration': taskDuration, 'fileName': fileName, 'destinationFileName': destinationFileName, 'fileSize': fileSize, 'timestampStart': str(timestampStart), 'timestampEnd': str(timestampEnd) }
return web.json_response(response_obj)
except Exception as e:
response_obj = { 'status' : 'failed', 'message': str(e) }
return web.json_response(response_obj)
except Exception as e:
response_obj = { 'status' : 'failed', 'message': str(e) }
return web.json_response(response_obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n filename = str(time.time())\n filepath = os.path.join(\n os.path.join(current_app.config['UPLOAD_FOLDER'], filename))\n with open(filepath, 'bw') as uploadfile:\n chunk_size = 1024\n while True:\n chunk = request.stream.read(chu... | [
"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.577518 | 96 |
POST handler that downloads file from remote host. | async def DownloadFromRemoteNodeHandler(request):
fileSize = 0
timestampStart = datetime.utcnow()
usedHandler = 'downloadFileFromRemoteNode'
try:
data = await request.post()
try:
testId = data['testId']
except Exception as e:
print('no testId, generating own')
testId = str(uuid.uuid4())
try:
fileName = data['destinationFileName']
except Exception as e:
print('no fileName, generating own')
fileName = "".join(choice(allchar) for x in range(randint(5, 5)))
try:
sourceHost = data['sourceHost']
sourceFileName = data['sourceFileName']
except Exception as e:
print('no sourceHost and sourceFileName')
fileUrl = 'http://'+sourceHost+'/downloadFile/'+sourceFileName+'/'+testId
async with ClientSession() as session:
try:
async with session.get(fileUrl) as response:
async for data in response.content.iter_chunked(1024):
fileSize += len(data)
timestampEnd = datetime.utcnow()
taskDuration = str(timestampEnd - timestampStart)
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["fileName"] = fileName
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["sourceFileName"] = sourceFileName
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["fileSize"] = fileSize
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["timestampStart"] = str(timestampStart)
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["timestampEnd"] = str(timestampEnd)
testResults.setdefault(testId, {}).setdefault(usedHandler, {})["taskDuration"] = taskDuration
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) }
return web.json_response(response_obj)
except Exception as e:
response_obj = { 'status' : 'failed', 'message': str(e) }
return web.json_response(response_obj)
except Exception as e:
response_obj = { 'status' : 'failed', 'message': str(e) }
return web.json_response(response_obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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(f... | [
"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.0 | -1 |
calculates the information reduction between layers This function computes the multiinformation (total correlation) reduction after a linear transformation. | def information_reduction(
X: np.ndarray, Y: np.ndarray, uni_entropy: Callable, tol_dims: int, p: float = 0.25,
) -> float:
# calculate the marginal entropy
hx = jax.vmap(uni_entropy)(X.T)
hy = jax.vmap(uni_entropy)(Y.T)
# Information content
delta_info = np.sum(hy) - np.sum(hx)
tol_info = np.sqrt(np.sum((hy - hx) ** 2))
# get tolerance
n_dimensions = X.shape[1]
# conditional
cond = np.logical_or(
tol_info < np.sqrt(n_dimensions * p * tol_dims ** 2), delta_info < 0
)
return np.array(np.where(cond, 0.0, delta_info)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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'], i... | [
"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.49604... | 0.45976505 | 86 |
Reads choice and directs on a path depending on input | def main_page(self):
choice = ""
while choice != "x":
header, main_menu, choices, underline = self.__get_format.main_menu_format()
choice = self.__main_menu.main_page(header,main_menu,choices,underline)
if choice == "1":
self.__rent_controller.Rent_page()
elif choice == "2":
try_again = ""
while try_again != "n":
try_again, valid = self.__salesman_controller.sign_in_page()
if valid == True:
self.__salesman_controller.salesman_menu()
elif choice == "3":
self.__order_controller.find_order_process(page=2)
elif choice == "i":
self.__information_controller.information_page() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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... | [
"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.568... | 0.0 | -1 |
Run all dispatch tests | def dispatch():
suite = ServiceTestSuite()
suite.addTest(unittest.makeSuite(AmazonTestCase, 'test_dispatch'))
return suite | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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... | [
"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.652... | 0.6487395 | 21 |
Run all local tests | def local():
suite = ServiceTestSuite()
suite.addTest(unittest.makeSuite(AmazonTestCase, 'test_local'))
return suite | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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():\... | [
"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.0 | -1 |
Run all network tests | def net():
suite = ServiceTestSuite()
suite.addTest(unittest.makeSuite(AmazonTestCase, 'test_net'))
return suite | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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()",
... | [
"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.6638301... | 0.0 | -1 |
enforceZeroSlope ensures that the last slope of all elbow fits is always 0 | def find_elbows_per_boots(dfr, nElbows, enforceZeroSlope=False):
rows = []
for dotmode, dfp in dfr.groupby('dotmode'):
if dotmode == '3d':
# always take out 3d's first two dis
# since pcor's correlation with duration is too weak to fit pmf
dfp = remove_dis(dfp, [1, 2], dotmode)
for bi, dfpts in dfp.groupby('bi'):
row = find_elbows_one_boot(dfpts, nElbows, enforceZeroSlope)
row.update({'dotmode': dotmode, 'bi': bi})
rows.append(row)
return pd.DataFrame(rows) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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.splitDat... | [
"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.51615... | 0.0 | -1 |
Instance data use_wsdl if True try to construct XML Instance from information in WSDL. | def __init__(self, wsdl, service=None, port=None, tracefile=None,
typesmodule=None, nsdict=None, soapAction=None, ns=None, op_ns=None, use_wsdl=False):
if not hasattr(wsdl, 'targetNamespace'):
wsdl = wstools.WSDLTools.WSDLReader().loadFromURL(wsdl)
# for item in wsdl.types.items():
# self._serializer.loadSchema(item)
self._service = wsdl.services[service or 0]
self.__doc__ = self._service.documentation
self._port = self._service.ports[port or 0]
self._name = self._service.name
self._wsdl = wsdl
self._tracefile = tracefile
self._typesmodule = typesmodule
self._nsdict = nsdict or {}
self._soapAction = soapAction
self._ns = ns
self._op_ns = op_ns
self._use_wsdl = use_wsdl
binding = self._port.getBinding()
portType = binding.getPortType()
for item in portType.operations:
callinfo = wstools.WSDLTools.callInfoFromWSDL(self._port, item.name)
method = MethodProxy(self, callinfo)
setattr(self, item.name, method) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 ... | [
"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.4... | 0.54205626 | 1 |
Call the named remote web service method. | def _call(self, name, *args, **kwargs):
if len(args) and len(kwargs):
raise TypeError(
'Use positional or keyword argument only.'
)
callinfo = getattr(self, name).callinfo
soapAction = callinfo.soapAction
url = callinfo.location
(protocol, host, uri, query, fragment, identifier) = urlparse(url)
port = '80'
if host.find(':') >= 0:
host, port = host.split(':')
binding = Binding(host=host, tracefile=self._tracefile,
ssl=(protocol == 'https'),
port=port, url=None, typesmodule=self._typesmodule,
nsdict=self._nsdict, soapaction=self._soapAction,
ns=self._ns, op_ns=self._op_ns)
if self._use_wsdl:
request, response = self._getTypeCodes(callinfo)
if len(kwargs): args = kwargs
if request is None:
request = Any(oname=name)
binding.Send(url=uri, opname=None, obj=args,
nsdict=self._nsdict, soapaction=soapAction, requesttypecode=request)
return binding.Receive(replytype=response)
apply(getattr(binding, callinfo.methodName), args)
return binding.Receive() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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.... | [
"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.6306776 | 11 |
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. | def _getTypeCodes(self, callinfo):
prefix = None
self._resetPrefixDict()
if callinfo.use == 'encoded':
prefix = self._getPrefix(callinfo.namespace)
try:
requestTC = self._getTypeCode(parameters=callinfo.getInParameters(), literal=(callinfo.use=='literal'))
except EvaluateException, ex:
print "DEBUG: Request Failed to generate --", ex
requestTC = None
self._resetPrefixDict()
try:
replyTC = self._getTypeCode(parameters=callinfo.getOutParameters(), literal=(callinfo.use=='literal'))
except EvaluateException, ex:
print "DEBUG: Response Failed to generate --", ex
replyTC = None
request = response = None
if callinfo.style == 'rpc':
if requestTC: request = TC.Struct(pyclass=None, ofwhat=requestTC, pname=callinfo.methodName)
if replyTC: response = TC.Struct(pyclass=None, ofwhat=replyTC, pname='%sResponse' %callinfo.methodName)
else:
if requestTC: request = requestTC[0]
if replyTC: response = replyTC[0]
#THIS IS FOR RPC/ENCODED, DOC/ENCODED Wrapper
if request and prefix and callinfo.use == 'encoded':
request.oname = '%(prefix)s:%(name)s xmlns:%(prefix)s="%(namespaceURI)s"' \
%{'prefix':prefix, 'name':request.oname, 'namespaceURI':callinfo.namespace}
return request, response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 == 'OMAT... | [
"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.4... | 0.73895764 | 0 |
Returns typecodes representing a parameter set parameters list of WSDLTools.ParameterInfo instances representing the parts of a WSDL Message. | def _getTypeCode(self, parameters, literal=False):
ofwhat = []
for part in parameters:
namespaceURI,localName = part.type
if part.element_type:
#global element
element = self._wsdl.types[namespaceURI].elements[localName]
tc = self._getElement(element, literal=literal, local=False, namespaceURI=namespaceURI)
else:
#local element
name = part.name
typeClass = self._getTypeClass(namespaceURI, localName)
if not typeClass:
tp = self._wsdl.types[namespaceURI].types[localName]
tc = self._getType(tp, name, literal, local=True, namespaceURI=namespaceURI)
else:
tc = typeClass(name)
ofwhat.append(tc)
return ofwhat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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[st... | [
"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.61186475 | 5 |
namespaces typecodes representing global elements with literal encoding. typeCode typecode representing an element. namespaceURI namespace literal True/False | def _globalElement(self, typeCode, namespaceURI, literal):
if literal:
typeCode.oname = '%(prefix)s:%(name)s xmlns:%(prefix)s="%(namespaceURI)s"' \
%{'prefix':self._getPrefix(namespaceURI), 'name':typeCode.oname, 'namespaceURI':namespaceURI} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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.... | [
"0.66442066",
"0.5593534",
"0.5443724",
"0.5412149",
"0.5365882",
"0.5329653",
"0.5311929",
"0.5237586",
"0.5178215",
"0.5165827",
"0.5055696",
"0.5044016",
"0.5007665",
"0.4926739",
"0.48959085",
"0.48641986",
"0.48631665",
"0.4855509",
"0.48434836",
"0.48183277",
"0.4792356... | 0.6797826 | 0 |
Retrieves a prefix/namespace mapping. namespaceURI namespace | def _getPrefix(self, namespaceURI):
prefixDict = self._getPrefixDict()
if prefixDict.has_key(namespaceURI):
prefix = prefixDict[namespaceURI]
else:
prefix = 'ns1'
while prefix in prefixDict.values():
prefix = 'ns%d' %int(prefix[-1]) + 1
prefixDict[namespaceURI] = prefix
return prefix | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prefix_to_ns(self, prefix):\n defin = self.module.i_ctx.get_module(\n self.module.i_prefixes[prefix][0])\n return defin.search_one(\"namespace\").arg",
"def get_namespace(self, prefix):\n try:\n return self.parser.namespaces[prefix]\n except KeyError as err:\... | [
"0.74894905",
"0.723001",
"0.7178781",
"0.7092518",
"0.7036941",
"0.6799343",
"0.67157125",
"0.67054284",
"0.66477394",
"0.6579663",
"0.64730036",
"0.646861",
"0.6420464",
"0.64164484",
"0.64045894",
"0.63432497",
"0.63370234",
"0.63120365",
"0.63070714",
"0.62537974",
"0.623... | 0.78372264 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.